~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Andrew Bennetts
  • Date: 2011-05-16 10:08:01 UTC
  • mto: This revision was merged to the branch mainline in revision 5865.
  • Revision ID: andrew.bennetts@canonical.com-20110516100801-81ookklkd9be2e3a
Move duplicate definitions of {Knit,GroupCompress}VersionedFiles.get_known_graph_ancestry into VersionedFilesWithFallbacks.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
27
27
        config as _mod_config,
28
28
        debug,
29
29
        errors,
 
30
        fetch,
 
31
        graph as _mod_graph,
30
32
        lockdir,
31
33
        lockable_files,
 
34
        remote,
32
35
        repository,
33
36
        revision as _mod_revision,
34
37
        rio,
39
42
        urlutils,
40
43
        )
41
44
from bzrlib.config import BranchConfig, TransportConfig
42
 
from bzrlib.repofmt.pack_repo import RepositoryFormatKnitPack5RichRoot
43
45
from bzrlib.tag import (
44
46
    BasicTags,
45
47
    DisabledTags,
46
48
    )
47
49
""")
48
50
 
49
 
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
50
 
from bzrlib.hooks import HookPoint, Hooks
 
51
from bzrlib import (
 
52
    controldir,
 
53
    )
 
54
from bzrlib.decorators import (
 
55
    needs_read_lock,
 
56
    needs_write_lock,
 
57
    only_raises,
 
58
    )
 
59
from bzrlib.hooks import Hooks
51
60
from bzrlib.inter import InterObject
52
 
from bzrlib.lock import _RelockDebugMixin
 
61
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
53
62
from bzrlib import registry
54
63
from bzrlib.symbol_versioning import (
55
64
    deprecated_in,
63
72
BZR_BRANCH_FORMAT_6 = "Bazaar Branch Format 6 (bzr 0.15)\n"
64
73
 
65
74
 
66
 
class Branch(bzrdir.ControlComponent):
 
75
class Branch(controldir.ControlComponent):
67
76
    """Branch holding a history of revisions.
68
77
 
69
78
    :ivar base:
70
79
        Base directory/url of the branch; using control_url and
71
80
        control_transport is more standardized.
72
 
 
73
 
    hooks: An instance of BranchHooks.
 
81
    :ivar hooks: An instance of BranchHooks.
 
82
    :ivar _master_branch_cache: cached result of get_master_branch, see
 
83
        _clear_cached_state.
74
84
    """
75
85
    # this is really an instance variable - FIXME move it there
76
86
    # - RBC 20060112
90
100
        self._revision_id_to_revno_cache = None
91
101
        self._partial_revision_id_to_revno_cache = {}
92
102
        self._partial_revision_history_cache = []
 
103
        self._tags_bytes = None
93
104
        self._last_revision_info_cache = None
 
105
        self._master_branch_cache = None
94
106
        self._merge_sorted_revisions_cache = None
95
107
        self._open_hook()
96
108
        hooks = Branch.hooks['open']
102
114
 
103
115
    def _activate_fallback_location(self, url):
104
116
        """Activate the branch/repository from url as a fallback repository."""
 
117
        for existing_fallback_repo in self.repository._fallback_repositories:
 
118
            if existing_fallback_repo.user_url == url:
 
119
                # This fallback is already configured.  This probably only
 
120
                # happens because BzrDir.sprout is a horrible mess.  To avoid
 
121
                # confusing _unstack we don't add this a second time.
 
122
                mutter('duplicate activation of fallback %r on %r', url, self)
 
123
                return
105
124
        repo = self._get_fallback_repository(url)
106
125
        if repo.has_same_location(self.repository):
107
126
            raise errors.UnstackableLocationError(self.user_url, url)
197
216
        return self.supports_tags() and self.tags.get_tag_dict()
198
217
 
199
218
    def get_config(self):
 
219
        """Get a bzrlib.config.BranchConfig for this Branch.
 
220
 
 
221
        This can then be used to get and set configuration options for the
 
222
        branch.
 
223
 
 
224
        :return: A bzrlib.config.BranchConfig.
 
225
        """
200
226
        return BranchConfig(self)
201
227
 
202
228
    def _get_config(self):
218
244
            possible_transports=[self.bzrdir.root_transport])
219
245
        return a_branch.repository
220
246
 
 
247
    @needs_read_lock
221
248
    def _get_tags_bytes(self):
222
249
        """Get the bytes of a serialised tags dict.
223
250
 
230
257
        :return: The bytes of the tags file.
231
258
        :seealso: Branch._set_tags_bytes.
232
259
        """
233
 
        return self._transport.get_bytes('tags')
 
260
        if self._tags_bytes is None:
 
261
            self._tags_bytes = self._transport.get_bytes('tags')
 
262
        return self._tags_bytes
234
263
 
235
264
    def _get_nick(self, local=False, possible_transports=None):
236
265
        config = self.get_config()
238
267
        if not local and not config.has_explicit_nickname():
239
268
            try:
240
269
                master = self.get_master_branch(possible_transports)
 
270
                if master and self.user_url == master.user_url:
 
271
                    raise errors.RecursiveBind(self.user_url)
241
272
                if master is not None:
242
273
                    # return the master branch value
243
274
                    return master.nick
 
275
            except errors.RecursiveBind, e:
 
276
                raise e
244
277
            except errors.BzrError, e:
245
278
                # Silently fall back to local implicit nick if the master is
246
279
                # unavailable
295
328
    def lock_read(self):
296
329
        """Lock the branch for read operations.
297
330
 
298
 
        :return: An object with an unlock method which will release the lock
299
 
            obtained.
 
331
        :return: A bzrlib.lock.LogicalLockResult.
300
332
        """
301
333
        raise NotImplementedError(self.lock_read)
302
334
 
637
669
        raise errors.UnsupportedOperation(self.get_reference_info, self)
638
670
 
639
671
    @needs_write_lock
640
 
    def fetch(self, from_branch, last_revision=None, pb=None):
 
672
    def fetch(self, from_branch, last_revision=None):
641
673
        """Copy revisions from from_branch into this branch.
642
674
 
643
675
        :param from_branch: Where to copy from.
644
676
        :param last_revision: What revision to stop at (None for at the end
645
677
                              of the branch.
646
 
        :param pb: An optional progress bar to use.
647
678
        :return: None
648
679
        """
649
 
        if self.base == from_branch.base:
650
 
            return (0, [])
651
 
        if pb is not None:
652
 
            symbol_versioning.warn(
653
 
                symbol_versioning.deprecated_in((1, 14, 0))
654
 
                % "pb parameter to fetch()")
655
 
        from_branch.lock_read()
656
 
        try:
657
 
            if last_revision is None:
658
 
                last_revision = from_branch.last_revision()
659
 
                last_revision = _mod_revision.ensure_null(last_revision)
660
 
            return self.repository.fetch(from_branch.repository,
661
 
                                         revision_id=last_revision,
662
 
                                         pb=pb)
663
 
        finally:
664
 
            from_branch.unlock()
 
680
        return InterBranch.get(from_branch, self).fetch(last_revision)
665
681
 
666
682
    def get_bound_location(self):
667
683
        """Return the URL of the branch we are bound to.
678
694
 
679
695
    def get_commit_builder(self, parents, config=None, timestamp=None,
680
696
                           timezone=None, committer=None, revprops=None,
681
 
                           revision_id=None):
 
697
                           revision_id=None, lossy=False):
682
698
        """Obtain a CommitBuilder for this branch.
683
699
 
684
700
        :param parents: Revision ids of the parents of the new revision.
688
704
        :param committer: Optional committer to set for commit.
689
705
        :param revprops: Optional dictionary of revision properties.
690
706
        :param revision_id: Optional revision id.
 
707
        :param lossy: Whether to discard data that can not be natively
 
708
            represented, when pushing to a foreign VCS 
691
709
        """
692
710
 
693
711
        if config is None:
694
712
            config = self.get_config()
695
713
 
696
714
        return self.repository.get_commit_builder(self, parents, config,
697
 
            timestamp, timezone, committer, revprops, revision_id)
 
715
            timestamp, timezone, committer, revprops, revision_id,
 
716
            lossy)
698
717
 
699
718
    def get_master_branch(self, possible_transports=None):
700
719
        """Return the branch we are bound to.
727
746
        """Print `file` to stdout."""
728
747
        raise NotImplementedError(self.print_file)
729
748
 
 
749
    @deprecated_method(deprecated_in((2, 4, 0)))
730
750
    def set_revision_history(self, rev_history):
731
 
        raise NotImplementedError(self.set_revision_history)
 
751
        """See Branch.set_revision_history."""
 
752
        self._set_revision_history(rev_history)
 
753
 
 
754
    @needs_write_lock
 
755
    def _set_revision_history(self, rev_history):
 
756
        if len(rev_history) == 0:
 
757
            revid = _mod_revision.NULL_REVISION
 
758
        else:
 
759
            revid = rev_history[-1]
 
760
        if rev_history != self._lefthand_history(revid):
 
761
            raise errors.NotLefthandHistory(rev_history)
 
762
        self.set_last_revision_info(len(rev_history), revid)
 
763
        self._cache_revision_history(rev_history)
 
764
        for hook in Branch.hooks['set_rh']:
 
765
            hook(self, rev_history)
 
766
 
 
767
    @needs_write_lock
 
768
    def set_last_revision_info(self, revno, revision_id):
 
769
        """Set the last revision of this branch.
 
770
 
 
771
        The caller is responsible for checking that the revno is correct
 
772
        for this revision id.
 
773
 
 
774
        It may be possible to set the branch last revision to an id not
 
775
        present in the repository.  However, branches can also be
 
776
        configured to check constraints on history, in which case this may not
 
777
        be permitted.
 
778
        """
 
779
        raise NotImplementedError(self.last_revision_info)
 
780
 
 
781
    @needs_write_lock
 
782
    def generate_revision_history(self, revision_id, last_rev=None,
 
783
                                  other_branch=None):
 
784
        """See Branch.generate_revision_history"""
 
785
        # FIXME: This shouldn't have to fetch the entire history
 
786
        history = self._lefthand_history(revision_id, last_rev, other_branch)
 
787
        revno = len(history)
 
788
        self.set_last_revision_info(revno, revision_id)
 
789
        self._cache_revision_history(history)
732
790
 
733
791
    @needs_write_lock
734
792
    def set_parent(self, url):
778
836
 
779
837
    def _unstack(self):
780
838
        """Change a branch to be unstacked, copying data as needed.
781
 
        
 
839
 
782
840
        Don't call this directly, use set_stacked_on_url(None).
783
841
        """
784
842
        pb = ui.ui_factory.nested_progress_bar()
793
851
            old_repository = self.repository
794
852
            if len(old_repository._fallback_repositories) != 1:
795
853
                raise AssertionError("can't cope with fallback repositories "
796
 
                    "of %r" % (self.repository,))
797
 
            # unlock it, including unlocking the fallback
 
854
                    "of %r (fallbacks: %r)" % (old_repository,
 
855
                        old_repository._fallback_repositories))
 
856
            # Open the new repository object.
 
857
            # Repositories don't offer an interface to remove fallback
 
858
            # repositories today; take the conceptually simpler option and just
 
859
            # reopen it.  We reopen it starting from the URL so that we
 
860
            # get a separate connection for RemoteRepositories and can
 
861
            # stream from one of them to the other.  This does mean doing
 
862
            # separate SSH connection setup, but unstacking is not a
 
863
            # common operation so it's tolerable.
 
864
            new_bzrdir = bzrdir.BzrDir.open(self.bzrdir.root_transport.base)
 
865
            new_repository = new_bzrdir.find_repository()
 
866
            if new_repository._fallback_repositories:
 
867
                raise AssertionError("didn't expect %r to have "
 
868
                    "fallback_repositories"
 
869
                    % (self.repository,))
 
870
            # Replace self.repository with the new repository.
 
871
            # Do our best to transfer the lock state (i.e. lock-tokens and
 
872
            # lock count) of self.repository to the new repository.
 
873
            lock_token = old_repository.lock_write().repository_token
 
874
            self.repository = new_repository
 
875
            if isinstance(self, remote.RemoteBranch):
 
876
                # Remote branches can have a second reference to the old
 
877
                # repository that need to be replaced.
 
878
                if self._real_branch is not None:
 
879
                    self._real_branch.repository = new_repository
 
880
            self.repository.lock_write(token=lock_token)
 
881
            if lock_token is not None:
 
882
                old_repository.leave_lock_in_place()
798
883
            old_repository.unlock()
 
884
            if lock_token is not None:
 
885
                # XXX: self.repository.leave_lock_in_place() before this
 
886
                # function will not be preserved.  Fortunately that doesn't
 
887
                # affect the current default format (2a), and would be a
 
888
                # corner-case anyway.
 
889
                #  - Andrew Bennetts, 2010/06/30
 
890
                self.repository.dont_leave_lock_in_place()
 
891
            old_lock_count = 0
 
892
            while True:
 
893
                try:
 
894
                    old_repository.unlock()
 
895
                except errors.LockNotHeld:
 
896
                    break
 
897
                old_lock_count += 1
 
898
            if old_lock_count == 0:
 
899
                raise AssertionError(
 
900
                    'old_repository should have been locked at least once.')
 
901
            for i in range(old_lock_count-1):
 
902
                self.repository.lock_write()
 
903
            # Fetch from the old repository into the new.
799
904
            old_repository.lock_read()
800
905
            try:
801
 
                # Repositories don't offer an interface to remove fallback
802
 
                # repositories today; take the conceptually simpler option and just
803
 
                # reopen it.  We reopen it starting from the URL so that we
804
 
                # get a separate connection for RemoteRepositories and can
805
 
                # stream from one of them to the other.  This does mean doing
806
 
                # separate SSH connection setup, but unstacking is not a
807
 
                # common operation so it's tolerable.
808
 
                new_bzrdir = bzrdir.BzrDir.open(self.bzrdir.root_transport.base)
809
 
                new_repository = new_bzrdir.find_repository()
810
 
                self.repository = new_repository
811
 
                if self.repository._fallback_repositories:
812
 
                    raise AssertionError("didn't expect %r to have "
813
 
                        "fallback_repositories"
814
 
                        % (self.repository,))
815
 
                # this is not paired with an unlock because it's just restoring
816
 
                # the previous state; the lock's released when set_stacked_on_url
817
 
                # returns
818
 
                self.repository.lock_write()
819
906
                # XXX: If you unstack a branch while it has a working tree
820
907
                # with a pending merge, the pending-merged revisions will no
821
908
                # longer be present.  You can (probably) revert and remerge.
822
 
                #
823
 
                # XXX: This only fetches up to the tip of the repository; it
824
 
                # doesn't bring across any tags.  That's fairly consistent
825
 
                # with how branch works, but perhaps not ideal.
826
 
                self.repository.fetch(old_repository,
827
 
                    revision_id=self.last_revision(),
828
 
                    find_ghosts=True)
 
909
                try:
 
910
                    tags_to_fetch = set(self.tags.get_reverse_tag_dict())
 
911
                except errors.TagsNotSupported:
 
912
                    tags_to_fetch = set()
 
913
                fetch_spec = _mod_graph.NotInOtherForRevs(self.repository,
 
914
                    old_repository, required_ids=[self.last_revision()],
 
915
                    if_present_ids=tags_to_fetch, find_ghosts=True).execute()
 
916
                self.repository.fetch(old_repository, fetch_spec=fetch_spec)
829
917
            finally:
830
918
                old_repository.unlock()
831
919
        finally:
836
924
 
837
925
        :seealso: Branch._get_tags_bytes.
838
926
        """
839
 
        return _run_with_write_locked_target(self, self._transport.put_bytes,
840
 
            'tags', bytes)
 
927
        return _run_with_write_locked_target(self, self._set_tags_bytes_locked,
 
928
                bytes)
 
929
 
 
930
    def _set_tags_bytes_locked(self, bytes):
 
931
        self._tags_bytes = bytes
 
932
        return self._transport.put_bytes('tags', bytes)
841
933
 
842
934
    def _cache_revision_history(self, rev_history):
843
935
        """Set the cached revision history to rev_history.
870
962
        self._revision_history_cache = None
871
963
        self._revision_id_to_revno_cache = None
872
964
        self._last_revision_info_cache = None
 
965
        self._master_branch_cache = None
873
966
        self._merge_sorted_revisions_cache = None
874
967
        self._partial_revision_history_cache = []
875
968
        self._partial_revision_id_to_revno_cache = {}
 
969
        self._tags_bytes = None
876
970
 
877
971
    def _gen_revision_history(self):
878
972
        """Return sequence of revision hashes on to this branch.
928
1022
        :return: A tuple (revno, revision_id).
929
1023
        """
930
1024
        if self._last_revision_info_cache is None:
931
 
            self._last_revision_info_cache = self._last_revision_info()
 
1025
            self._last_revision_info_cache = self._read_last_revision_info()
932
1026
        return self._last_revision_info_cache
933
1027
 
934
 
    def _last_revision_info(self):
935
 
        rh = self.revision_history()
936
 
        revno = len(rh)
937
 
        if revno:
938
 
            return (revno, rh[-1])
939
 
        else:
940
 
            return (0, _mod_revision.NULL_REVISION)
941
 
 
942
 
    @deprecated_method(deprecated_in((1, 6, 0)))
943
 
    def missing_revisions(self, other, stop_revision=None):
944
 
        """Return a list of new revisions that would perfectly fit.
945
 
 
946
 
        If self and other have not diverged, return a list of the revisions
947
 
        present in other, but missing from self.
948
 
        """
949
 
        self_history = self.revision_history()
950
 
        self_len = len(self_history)
951
 
        other_history = other.revision_history()
952
 
        other_len = len(other_history)
953
 
        common_index = min(self_len, other_len) -1
954
 
        if common_index >= 0 and \
955
 
            self_history[common_index] != other_history[common_index]:
956
 
            raise errors.DivergedBranches(self, other)
957
 
 
958
 
        if stop_revision is None:
959
 
            stop_revision = other_len
960
 
        else:
961
 
            if stop_revision > other_len:
962
 
                raise errors.NoSuchRevision(self, stop_revision)
963
 
        return other_history[self_len:stop_revision]
964
 
 
965
 
    @needs_write_lock
966
 
    def update_revisions(self, other, stop_revision=None, overwrite=False,
967
 
                         graph=None):
968
 
        """Pull in new perfect-fit revisions.
969
 
 
970
 
        :param other: Another Branch to pull from
971
 
        :param stop_revision: Updated until the given revision
972
 
        :param overwrite: Always set the branch pointer, rather than checking
973
 
            to see if it is a proper descendant.
974
 
        :param graph: A Graph object that can be used to query history
975
 
            information. This can be None.
976
 
        :return: None
977
 
        """
978
 
        return InterBranch.get(other, self).update_revisions(stop_revision,
979
 
            overwrite, graph)
980
 
 
 
1028
    def _read_last_revision_info(self):
 
1029
        raise NotImplementedError(self._read_last_revision_info)
 
1030
 
 
1031
    @deprecated_method(deprecated_in((2, 4, 0)))
981
1032
    def import_last_revision_info(self, source_repo, revno, revid):
982
1033
        """Set the last revision info, importing from another repo if necessary.
983
1034
 
984
 
        This is used by the bound branch code to upload a revision to
985
 
        the master branch first before updating the tip of the local branch.
986
 
 
987
1035
        :param source_repo: Source repository to optionally fetch from
988
1036
        :param revno: Revision number of the new tip
989
1037
        :param revid: Revision id of the new tip
992
1040
            self.repository.fetch(source_repo, revision_id=revid)
993
1041
        self.set_last_revision_info(revno, revid)
994
1042
 
 
1043
    def import_last_revision_info_and_tags(self, source, revno, revid,
 
1044
                                           lossy=False):
 
1045
        """Set the last revision info, importing from another repo if necessary.
 
1046
 
 
1047
        This is used by the bound branch code to upload a revision to
 
1048
        the master branch first before updating the tip of the local branch.
 
1049
        Revisions referenced by source's tags are also transferred.
 
1050
 
 
1051
        :param source: Source branch to optionally fetch from
 
1052
        :param revno: Revision number of the new tip
 
1053
        :param revid: Revision id of the new tip
 
1054
        :param lossy: Whether to discard metadata that can not be
 
1055
            natively represented
 
1056
        :return: Tuple with the new revision number and revision id
 
1057
            (should only be different from the arguments when lossy=True)
 
1058
        """
 
1059
        if not self.repository.has_same_location(source.repository):
 
1060
            self.fetch(source, revid)
 
1061
        self.set_last_revision_info(revno, revid)
 
1062
        return (revno, revid)
 
1063
 
995
1064
    def revision_id_to_revno(self, revision_id):
996
1065
        """Given a revision id, return its revno"""
997
1066
        if _mod_revision.is_null(revision_id):
1017
1086
            self._extend_partial_history(distance_from_last)
1018
1087
        return self._partial_revision_history_cache[distance_from_last]
1019
1088
 
1020
 
    @needs_write_lock
1021
1089
    def pull(self, source, overwrite=False, stop_revision=None,
1022
1090
             possible_transports=None, *args, **kwargs):
1023
1091
        """Mirror source into this branch.
1219
1287
        return result
1220
1288
 
1221
1289
    @needs_read_lock
1222
 
    def sprout(self, to_bzrdir, revision_id=None, repository_policy=None):
 
1290
    def sprout(self, to_bzrdir, revision_id=None, repository_policy=None,
 
1291
            repository=None):
1223
1292
        """Create a new line of development from the branch, into to_bzrdir.
1224
1293
 
1225
1294
        to_bzrdir controls the branch format.
1230
1299
        if (repository_policy is not None and
1231
1300
            repository_policy.requires_stacking()):
1232
1301
            to_bzrdir._format.require_stacking(_skip_repo=True)
1233
 
        result = to_bzrdir.create_branch()
 
1302
        result = to_bzrdir.create_branch(repository=repository)
1234
1303
        result.lock_write()
1235
1304
        try:
1236
1305
            if repository_policy is not None:
1237
1306
                repository_policy.configure_branch(result)
1238
1307
            self.copy_content_into(result, revision_id=revision_id)
1239
 
            result.set_parent(self.bzrdir.root_transport.base)
 
1308
            master_branch = self.get_master_branch()
 
1309
            if master_branch is None:
 
1310
                result.set_parent(self.bzrdir.root_transport.base)
 
1311
            else:
 
1312
                result.set_parent(master_branch.bzrdir.root_transport.base)
1240
1313
        finally:
1241
1314
            result.unlock()
1242
1315
        return result
1266
1339
                revno = 1
1267
1340
        destination.set_last_revision_info(revno, revision_id)
1268
1341
 
1269
 
    @needs_read_lock
1270
1342
    def copy_content_into(self, destination, revision_id=None):
1271
1343
        """Copy the content of self into destination.
1272
1344
 
1273
1345
        revision_id: if not None, the revision history in the new branch will
1274
1346
                     be truncated to end with revision_id.
1275
1347
        """
1276
 
        self.update_references(destination)
1277
 
        self._synchronize_history(destination, revision_id)
1278
 
        try:
1279
 
            parent = self.get_parent()
1280
 
        except errors.InaccessibleParent, e:
1281
 
            mutter('parent was not accessible to copy: %s', e)
1282
 
        else:
1283
 
            if parent:
1284
 
                destination.set_parent(parent)
1285
 
        if self._push_should_merge_tags():
1286
 
            self.tags.merge_to(destination.tags)
 
1348
        return InterBranch.get(self, destination).copy_content_into(
 
1349
            revision_id=revision_id)
1287
1350
 
1288
1351
    def update_references(self, target):
1289
1352
        if not getattr(self._format, 'supports_reference_locations', False):
1334
1397
        """Return the most suitable metadir for a checkout of this branch.
1335
1398
        Weaves are used if this branch's repository uses weaves.
1336
1399
        """
1337
 
        if isinstance(self.bzrdir, bzrdir.BzrDirPreSplitOut):
1338
 
            from bzrlib.repofmt import weaverepo
1339
 
            format = bzrdir.BzrDirMetaFormat1()
1340
 
            format.repository_format = weaverepo.RepositoryFormat7()
1341
 
        else:
1342
 
            format = self.repository.bzrdir.checkout_metadir()
1343
 
            format.set_branch_format(self._format)
 
1400
        format = self.repository.bzrdir.checkout_metadir()
 
1401
        format.set_branch_format(self._format)
1344
1402
        return format
1345
1403
 
1346
1404
    def create_clone_on_transport(self, to_transport, revision_id=None,
1347
 
        stacked_on=None, create_prefix=False, use_existing_dir=False):
 
1405
        stacked_on=None, create_prefix=False, use_existing_dir=False,
 
1406
        no_tree=None):
1348
1407
        """Create a clone of this branch and its bzrdir.
1349
1408
 
1350
1409
        :param to_transport: The transport to clone onto.
1357
1416
        """
1358
1417
        # XXX: Fix the bzrdir API to allow getting the branch back from the
1359
1418
        # clone call. Or something. 20090224 RBC/spiv.
 
1419
        # XXX: Should this perhaps clone colocated branches as well, 
 
1420
        # rather than just the default branch? 20100319 JRV
1360
1421
        if revision_id is None:
1361
1422
            revision_id = self.last_revision()
1362
1423
        dir_to = self.bzrdir.clone_on_transport(to_transport,
1363
1424
            revision_id=revision_id, stacked_on=stacked_on,
1364
 
            create_prefix=create_prefix, use_existing_dir=use_existing_dir)
 
1425
            create_prefix=create_prefix, use_existing_dir=use_existing_dir,
 
1426
            no_tree=no_tree)
1365
1427
        return dir_to.open_branch()
1366
1428
 
1367
1429
    def create_checkout(self, to_location, revision_id=None,
1482
1544
        else:
1483
1545
            raise AssertionError("invalid heads: %r" % (heads,))
1484
1546
 
1485
 
 
1486
 
class BranchFormat(object):
 
1547
    def heads_to_fetch(self):
 
1548
        """Return the heads that must and that should be fetched to copy this
 
1549
        branch into another repo.
 
1550
 
 
1551
        :returns: a 2-tuple of (must_fetch, if_present_fetch).  must_fetch is a
 
1552
            set of heads that must be fetched.  if_present_fetch is a set of
 
1553
            heads that must be fetched if present, but no error is necessary if
 
1554
            they are not present.
 
1555
        """
 
1556
        # For bzr native formats must_fetch is just the tip, and if_present_fetch
 
1557
        # are the tags.
 
1558
        must_fetch = set([self.last_revision()])
 
1559
        try:
 
1560
            if_present_fetch = set(self.tags.get_reverse_tag_dict())
 
1561
        except errors.TagsNotSupported:
 
1562
            if_present_fetch = set()
 
1563
        must_fetch.discard(_mod_revision.NULL_REVISION)
 
1564
        if_present_fetch.discard(_mod_revision.NULL_REVISION)
 
1565
        return must_fetch, if_present_fetch
 
1566
 
 
1567
 
 
1568
class BranchFormat(controldir.ControlComponentFormat):
1487
1569
    """An encapsulation of the initialization and open routines for a format.
1488
1570
 
1489
1571
    Formats provide three things:
1492
1574
     * an open routine.
1493
1575
 
1494
1576
    Formats are placed in an dict by their format string for reference
1495
 
    during branch opening. Its not required that these be instances, they
 
1577
    during branch opening. It's not required that these be instances, they
1496
1578
    can be classes themselves with class methods - it simply depends on
1497
1579
    whether state is needed for a given format or not.
1498
1580
 
1501
1583
    object will be created every time regardless.
1502
1584
    """
1503
1585
 
1504
 
    _default_format = None
1505
 
    """The default format used for new branches."""
1506
 
 
1507
 
    _formats = {}
1508
 
    """The known formats."""
1509
 
 
1510
1586
    can_set_append_revisions_only = True
1511
1587
 
1512
1588
    def __eq__(self, other):
1521
1597
        try:
1522
1598
            transport = a_bzrdir.get_branch_transport(None, name=name)
1523
1599
            format_string = transport.get_bytes("format")
1524
 
            return klass._formats[format_string]
 
1600
            return format_registry.get(format_string)
1525
1601
        except errors.NoSuchFile:
1526
1602
            raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1527
1603
        except KeyError:
1528
1604
            raise errors.UnknownFormatError(format=format_string, kind='branch')
1529
1605
 
1530
1606
    @classmethod
 
1607
    @deprecated_method(deprecated_in((2, 4, 0)))
1531
1608
    def get_default_format(klass):
1532
1609
        """Return the current default format."""
1533
 
        return klass._default_format
1534
 
 
1535
 
    def get_reference(self, a_bzrdir):
 
1610
        return format_registry.get_default()
 
1611
 
 
1612
    @classmethod
 
1613
    @deprecated_method(deprecated_in((2, 4, 0)))
 
1614
    def get_formats(klass):
 
1615
        """Get all the known formats.
 
1616
 
 
1617
        Warning: This triggers a load of all lazy registered formats: do not
 
1618
        use except when that is desireed.
 
1619
        """
 
1620
        return format_registry._get_all()
 
1621
 
 
1622
    def get_reference(self, a_bzrdir, name=None):
1536
1623
        """Get the target reference of the branch in a_bzrdir.
1537
1624
 
1538
1625
        format probing must have been completed before calling
1540
1627
        in a_bzrdir is correct.
1541
1628
 
1542
1629
        :param a_bzrdir: The bzrdir to get the branch data from.
 
1630
        :param name: Name of the colocated branch to fetch
1543
1631
        :return: None if the branch is not a reference branch.
1544
1632
        """
1545
1633
        return None
1546
1634
 
1547
1635
    @classmethod
1548
 
    def set_reference(self, a_bzrdir, to_branch):
 
1636
    def set_reference(self, a_bzrdir, name, to_branch):
1549
1637
        """Set the target reference of the branch in a_bzrdir.
1550
1638
 
1551
1639
        format probing must have been completed before calling
1553
1641
        in a_bzrdir is correct.
1554
1642
 
1555
1643
        :param a_bzrdir: The bzrdir to set the branch reference for.
 
1644
        :param name: Name of colocated branch to set, None for default
1556
1645
        :param to_branch: branch that the checkout is to reference
1557
1646
        """
1558
1647
        raise NotImplementedError(self.set_reference)
1573
1662
        for hook in hooks:
1574
1663
            hook(params)
1575
1664
 
1576
 
    def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
1577
 
                           lock_type='metadir', set_format=True):
1578
 
        """Initialize a branch in a bzrdir, with specified files
1579
 
 
1580
 
        :param a_bzrdir: The bzrdir to initialize the branch in
1581
 
        :param utf8_files: The files to create as a list of
1582
 
            (filename, content) tuples
1583
 
        :param name: Name of colocated branch to create, if any
1584
 
        :param set_format: If True, set the format with
1585
 
            self.get_format_string.  (BzrBranch4 has its format set
1586
 
            elsewhere)
1587
 
        :return: a branch in this format
1588
 
        """
1589
 
        mutter('creating branch %r in %s', self, a_bzrdir.user_url)
1590
 
        branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1591
 
        lock_map = {
1592
 
            'metadir': ('lock', lockdir.LockDir),
1593
 
            'branch4': ('branch-lock', lockable_files.TransportLock),
1594
 
        }
1595
 
        lock_name, lock_class = lock_map[lock_type]
1596
 
        control_files = lockable_files.LockableFiles(branch_transport,
1597
 
            lock_name, lock_class)
1598
 
        control_files.create_lock()
1599
 
        try:
1600
 
            control_files.lock_write()
1601
 
        except errors.LockContention:
1602
 
            if lock_type != 'branch4':
1603
 
                raise
1604
 
            lock_taken = False
1605
 
        else:
1606
 
            lock_taken = True
1607
 
        if set_format:
1608
 
            utf8_files += [('format', self.get_format_string())]
1609
 
        try:
1610
 
            for (filename, content) in utf8_files:
1611
 
                branch_transport.put_bytes(
1612
 
                    filename, content,
1613
 
                    mode=a_bzrdir._get_file_mode())
1614
 
        finally:
1615
 
            if lock_taken:
1616
 
                control_files.unlock()
1617
 
        branch = self.open(a_bzrdir, name, _found=True)
1618
 
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
1619
 
        return branch
1620
 
 
1621
 
    def initialize(self, a_bzrdir, name=None):
 
1665
    def initialize(self, a_bzrdir, name=None, repository=None):
1622
1666
        """Create a branch of this format in a_bzrdir.
1623
1667
        
1624
1668
        :param name: Name of the colocated branch to create.
1658
1702
        """
1659
1703
        raise NotImplementedError(self.network_name)
1660
1704
 
1661
 
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
 
1705
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False,
 
1706
            found_repository=None):
1662
1707
        """Return the branch object for a_bzrdir
1663
1708
 
1664
1709
        :param a_bzrdir: A BzrDir that contains a branch.
1671
1716
        raise NotImplementedError(self.open)
1672
1717
 
1673
1718
    @classmethod
 
1719
    @deprecated_method(deprecated_in((2, 4, 0)))
1674
1720
    def register_format(klass, format):
1675
 
        """Register a metadir format."""
1676
 
        klass._formats[format.get_format_string()] = format
1677
 
        # Metadir formats have a network name of their format string, and get
1678
 
        # registered as class factories.
1679
 
        network_format_registry.register(format.get_format_string(), format.__class__)
 
1721
        """Register a metadir format.
 
1722
 
 
1723
        See MetaDirBranchFormatFactory for the ability to register a format
 
1724
        without loading the code the format needs until it is actually used.
 
1725
        """
 
1726
        format_registry.register(format)
1680
1727
 
1681
1728
    @classmethod
 
1729
    @deprecated_method(deprecated_in((2, 4, 0)))
1682
1730
    def set_default_format(klass, format):
1683
 
        klass._default_format = format
 
1731
        format_registry.set_default(format)
1684
1732
 
1685
1733
    def supports_set_append_revisions_only(self):
1686
1734
        """True if this format supports set_append_revisions_only."""
1690
1738
        """True if this format records a stacked-on branch."""
1691
1739
        return False
1692
1740
 
 
1741
    def supports_leaving_lock(self):
 
1742
        """True if this format supports leaving locks in place."""
 
1743
        return False # by default
 
1744
 
1693
1745
    @classmethod
 
1746
    @deprecated_method(deprecated_in((2, 4, 0)))
1694
1747
    def unregister_format(klass, format):
1695
 
        del klass._formats[format.get_format_string()]
 
1748
        format_registry.remove(format)
1696
1749
 
1697
1750
    def __str__(self):
1698
1751
        return self.get_format_description().rstrip()
1702
1755
        return False  # by default
1703
1756
 
1704
1757
 
 
1758
class MetaDirBranchFormatFactory(registry._LazyObjectGetter):
 
1759
    """A factory for a BranchFormat object, permitting simple lazy registration.
 
1760
    
 
1761
    While none of the built in BranchFormats are lazy registered yet,
 
1762
    bzrlib.tests.test_branch.TestMetaDirBranchFormatFactory demonstrates how to
 
1763
    use it, and the bzr-loom plugin uses it as well (see
 
1764
    bzrlib.plugins.loom.formats).
 
1765
    """
 
1766
 
 
1767
    def __init__(self, format_string, module_name, member_name):
 
1768
        """Create a MetaDirBranchFormatFactory.
 
1769
 
 
1770
        :param format_string: The format string the format has.
 
1771
        :param module_name: Module to load the format class from.
 
1772
        :param member_name: Attribute name within the module for the format class.
 
1773
        """
 
1774
        registry._LazyObjectGetter.__init__(self, module_name, member_name)
 
1775
        self._format_string = format_string
 
1776
        
 
1777
    def get_format_string(self):
 
1778
        """See BranchFormat.get_format_string."""
 
1779
        return self._format_string
 
1780
 
 
1781
    def __call__(self):
 
1782
        """Used for network_format_registry support."""
 
1783
        return self.get_obj()()
 
1784
 
 
1785
 
1705
1786
class BranchHooks(Hooks):
1706
1787
    """A dictionary mapping hook name to a list of callables for branch hooks.
1707
1788
 
1715
1796
        These are all empty initially, because by default nothing should get
1716
1797
        notified.
1717
1798
        """
1718
 
        Hooks.__init__(self)
1719
 
        self.create_hook(HookPoint('set_rh',
 
1799
        Hooks.__init__(self, "bzrlib.branch", "Branch.hooks")
 
1800
        self.add_hook('set_rh',
1720
1801
            "Invoked whenever the revision history has been set via "
1721
1802
            "set_revision_history. The api signature is (branch, "
1722
1803
            "revision_history), and the branch will be write-locked. "
1723
1804
            "The set_rh hook can be expensive for bzr to trigger, a better "
1724
 
            "hook to use is Branch.post_change_branch_tip.", (0, 15), None))
1725
 
        self.create_hook(HookPoint('open',
 
1805
            "hook to use is Branch.post_change_branch_tip.", (0, 15))
 
1806
        self.add_hook('open',
1726
1807
            "Called with the Branch object that has been opened after a "
1727
 
            "branch is opened.", (1, 8), None))
1728
 
        self.create_hook(HookPoint('post_push',
 
1808
            "branch is opened.", (1, 8))
 
1809
        self.add_hook('post_push',
1729
1810
            "Called after a push operation completes. post_push is called "
1730
1811
            "with a bzrlib.branch.BranchPushResult object and only runs in the "
1731
 
            "bzr client.", (0, 15), None))
1732
 
        self.create_hook(HookPoint('post_pull',
 
1812
            "bzr client.", (0, 15))
 
1813
        self.add_hook('post_pull',
1733
1814
            "Called after a pull operation completes. post_pull is called "
1734
1815
            "with a bzrlib.branch.PullResult object and only runs in the "
1735
 
            "bzr client.", (0, 15), None))
1736
 
        self.create_hook(HookPoint('pre_commit',
1737
 
            "Called after a commit is calculated but before it is is "
 
1816
            "bzr client.", (0, 15))
 
1817
        self.add_hook('pre_commit',
 
1818
            "Called after a commit is calculated but before it is "
1738
1819
            "completed. pre_commit is called with (local, master, old_revno, "
1739
1820
            "old_revid, future_revno, future_revid, tree_delta, future_tree"
1740
1821
            "). old_revid is NULL_REVISION for the first commit to a branch, "
1742
1823
            "basis revision. hooks MUST NOT modify this delta. "
1743
1824
            " future_tree is an in-memory tree obtained from "
1744
1825
            "CommitBuilder.revision_tree() and hooks MUST NOT modify this "
1745
 
            "tree.", (0,91), None))
1746
 
        self.create_hook(HookPoint('post_commit',
 
1826
            "tree.", (0,91))
 
1827
        self.add_hook('post_commit',
1747
1828
            "Called in the bzr client after a commit has completed. "
1748
1829
            "post_commit is called with (local, master, old_revno, old_revid, "
1749
1830
            "new_revno, new_revid). old_revid is NULL_REVISION for the first "
1750
 
            "commit to a branch.", (0, 15), None))
1751
 
        self.create_hook(HookPoint('post_uncommit',
 
1831
            "commit to a branch.", (0, 15))
 
1832
        self.add_hook('post_uncommit',
1752
1833
            "Called in the bzr client after an uncommit completes. "
1753
1834
            "post_uncommit is called with (local, master, old_revno, "
1754
1835
            "old_revid, new_revno, new_revid) where local is the local branch "
1755
1836
            "or None, master is the target branch, and an empty branch "
1756
 
            "receives new_revno of 0, new_revid of None.", (0, 15), None))
1757
 
        self.create_hook(HookPoint('pre_change_branch_tip',
 
1837
            "receives new_revno of 0, new_revid of None.", (0, 15))
 
1838
        self.add_hook('pre_change_branch_tip',
1758
1839
            "Called in bzr client and server before a change to the tip of a "
1759
1840
            "branch is made. pre_change_branch_tip is called with a "
1760
1841
            "bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1761
 
            "commit, uncommit will all trigger this hook.", (1, 6), None))
1762
 
        self.create_hook(HookPoint('post_change_branch_tip',
 
1842
            "commit, uncommit will all trigger this hook.", (1, 6))
 
1843
        self.add_hook('post_change_branch_tip',
1763
1844
            "Called in bzr client and server after a change to the tip of a "
1764
1845
            "branch is made. post_change_branch_tip is called with a "
1765
1846
            "bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1766
 
            "commit, uncommit will all trigger this hook.", (1, 4), None))
1767
 
        self.create_hook(HookPoint('transform_fallback_location',
 
1847
            "commit, uncommit will all trigger this hook.", (1, 4))
 
1848
        self.add_hook('transform_fallback_location',
1768
1849
            "Called when a stacked branch is activating its fallback "
1769
1850
            "locations. transform_fallback_location is called with (branch, "
1770
1851
            "url), and should return a new url. Returning the same url "
1775
1856
            "fallback locations have not been activated. When there are "
1776
1857
            "multiple hooks installed for transform_fallback_location, "
1777
1858
            "all are called with the url returned from the previous hook."
1778
 
            "The order is however undefined.", (1, 9), None))
1779
 
        self.create_hook(HookPoint('automatic_tag_name',
1780
 
            "Called to determine an automatic tag name for a revision."
 
1859
            "The order is however undefined.", (1, 9))
 
1860
        self.add_hook('automatic_tag_name',
 
1861
            "Called to determine an automatic tag name for a revision. "
1781
1862
            "automatic_tag_name is called with (branch, revision_id) and "
1782
1863
            "should return a tag name or None if no tag name could be "
1783
1864
            "determined. The first non-None tag name returned will be used.",
1784
 
            (2, 2), None))
1785
 
        self.create_hook(HookPoint('post_branch_init',
 
1865
            (2, 2))
 
1866
        self.add_hook('post_branch_init',
1786
1867
            "Called after new branch initialization completes. "
1787
1868
            "post_branch_init is called with a "
1788
1869
            "bzrlib.branch.BranchInitHookParams. "
1789
1870
            "Note that init, branch and checkout (both heavyweight and "
1790
 
            "lightweight) will all trigger this hook.", (2, 2), None))
1791
 
        self.create_hook(HookPoint('post_switch',
 
1871
            "lightweight) will all trigger this hook.", (2, 2))
 
1872
        self.add_hook('post_switch',
1792
1873
            "Called after a checkout switches branch. "
1793
1874
            "post_switch is called with a "
1794
 
            "bzrlib.branch.SwitchHookParams.", (2, 2), None))
 
1875
            "bzrlib.branch.SwitchHookParams.", (2, 2))
1795
1876
 
1796
1877
 
1797
1878
 
1874
1955
        return self.__dict__ == other.__dict__
1875
1956
 
1876
1957
    def __repr__(self):
1877
 
        if self.branch:
1878
 
            return "<%s of %s>" % (self.__class__.__name__, self.branch)
1879
 
        else:
1880
 
            return "<%s of format:%s bzrdir:%s>" % (
1881
 
                self.__class__.__name__, self.branch,
1882
 
                self.format, self.bzrdir)
 
1958
        return "<%s of %s>" % (self.__class__.__name__, self.branch)
1883
1959
 
1884
1960
 
1885
1961
class SwitchHookParams(object):
1915
1991
            self.revision_id)
1916
1992
 
1917
1993
 
1918
 
class BzrBranchFormat4(BranchFormat):
1919
 
    """Bzr branch format 4.
1920
 
 
1921
 
    This format has:
1922
 
     - a revision-history file.
1923
 
     - a branch-lock lock file [ to be shared with the bzrdir ]
1924
 
    """
1925
 
 
1926
 
    def get_format_description(self):
1927
 
        """See BranchFormat.get_format_description()."""
1928
 
        return "Branch format 4"
1929
 
 
1930
 
    def initialize(self, a_bzrdir, name=None):
1931
 
        """Create a branch of this format in a_bzrdir."""
1932
 
        utf8_files = [('revision-history', ''),
1933
 
                      ('branch-name', ''),
1934
 
                      ]
1935
 
        return self._initialize_helper(a_bzrdir, utf8_files, name=name,
1936
 
                                       lock_type='branch4', set_format=False)
1937
 
 
1938
 
    def __init__(self):
1939
 
        super(BzrBranchFormat4, self).__init__()
1940
 
        self._matchingbzrdir = bzrdir.BzrDirFormat6()
1941
 
 
1942
 
    def network_name(self):
1943
 
        """The network name for this format is the control dirs disk label."""
1944
 
        return self._matchingbzrdir.get_format_string()
1945
 
 
1946
 
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
1947
 
        """See BranchFormat.open()."""
1948
 
        if not _found:
1949
 
            # we are being called directly and must probe.
1950
 
            raise NotImplementedError
1951
 
        return BzrBranch(_format=self,
1952
 
                         _control_files=a_bzrdir._control_files,
1953
 
                         a_bzrdir=a_bzrdir,
1954
 
                         name=name,
1955
 
                         _repository=a_bzrdir.open_repository())
1956
 
 
1957
 
    def __str__(self):
1958
 
        return "Bazaar-NG branch format 4"
1959
 
 
1960
 
 
1961
1994
class BranchFormatMetadir(BranchFormat):
1962
1995
    """Common logic for meta-dir based branch formats."""
1963
1996
 
1965
1998
        """What class to instantiate on open calls."""
1966
1999
        raise NotImplementedError(self._branch_class)
1967
2000
 
 
2001
    def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
 
2002
                           repository=None):
 
2003
        """Initialize a branch in a bzrdir, with specified files
 
2004
 
 
2005
        :param a_bzrdir: The bzrdir to initialize the branch in
 
2006
        :param utf8_files: The files to create as a list of
 
2007
            (filename, content) tuples
 
2008
        :param name: Name of colocated branch to create, if any
 
2009
        :return: a branch in this format
 
2010
        """
 
2011
        mutter('creating branch %r in %s', self, a_bzrdir.user_url)
 
2012
        branch_transport = a_bzrdir.get_branch_transport(self, name=name)
 
2013
        control_files = lockable_files.LockableFiles(branch_transport,
 
2014
            'lock', lockdir.LockDir)
 
2015
        control_files.create_lock()
 
2016
        control_files.lock_write()
 
2017
        try:
 
2018
            utf8_files += [('format', self.get_format_string())]
 
2019
            for (filename, content) in utf8_files:
 
2020
                branch_transport.put_bytes(
 
2021
                    filename, content,
 
2022
                    mode=a_bzrdir._get_file_mode())
 
2023
        finally:
 
2024
            control_files.unlock()
 
2025
        branch = self.open(a_bzrdir, name, _found=True,
 
2026
                found_repository=repository)
 
2027
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
 
2028
        return branch
 
2029
 
1968
2030
    def network_name(self):
1969
2031
        """A simple byte string uniquely identifying this format for RPC calls.
1970
2032
 
1972
2034
        """
1973
2035
        return self.get_format_string()
1974
2036
 
1975
 
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
 
2037
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False,
 
2038
            found_repository=None):
1976
2039
        """See BranchFormat.open()."""
1977
2040
        if not _found:
1978
2041
            format = BranchFormat.find_format(a_bzrdir, name=name)
1983
2046
        try:
1984
2047
            control_files = lockable_files.LockableFiles(transport, 'lock',
1985
2048
                                                         lockdir.LockDir)
 
2049
            if found_repository is None:
 
2050
                found_repository = a_bzrdir.find_repository()
1986
2051
            return self._branch_class()(_format=self,
1987
2052
                              _control_files=control_files,
1988
2053
                              name=name,
1989
2054
                              a_bzrdir=a_bzrdir,
1990
 
                              _repository=a_bzrdir.find_repository(),
 
2055
                              _repository=found_repository,
1991
2056
                              ignore_fallbacks=ignore_fallbacks)
1992
2057
        except errors.NoSuchFile:
1993
2058
            raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
2000
2065
    def supports_tags(self):
2001
2066
        return True
2002
2067
 
 
2068
    def supports_leaving_lock(self):
 
2069
        return True
 
2070
 
2003
2071
 
2004
2072
class BzrBranchFormat5(BranchFormatMetadir):
2005
2073
    """Bzr branch format 5.
2025
2093
        """See BranchFormat.get_format_description()."""
2026
2094
        return "Branch format 5"
2027
2095
 
2028
 
    def initialize(self, a_bzrdir, name=None):
 
2096
    def initialize(self, a_bzrdir, name=None, repository=None):
2029
2097
        """Create a branch of this format in a_bzrdir."""
2030
2098
        utf8_files = [('revision-history', ''),
2031
2099
                      ('branch-name', ''),
2032
2100
                      ]
2033
 
        return self._initialize_helper(a_bzrdir, utf8_files, name)
 
2101
        return self._initialize_helper(a_bzrdir, utf8_files, name, repository)
2034
2102
 
2035
2103
    def supports_tags(self):
2036
2104
        return False
2058
2126
        """See BranchFormat.get_format_description()."""
2059
2127
        return "Branch format 6"
2060
2128
 
2061
 
    def initialize(self, a_bzrdir, name=None):
 
2129
    def initialize(self, a_bzrdir, name=None, repository=None):
2062
2130
        """Create a branch of this format in a_bzrdir."""
2063
2131
        utf8_files = [('last-revision', '0 null:\n'),
2064
2132
                      ('branch.conf', ''),
2065
2133
                      ('tags', ''),
2066
2134
                      ]
2067
 
        return self._initialize_helper(a_bzrdir, utf8_files, name)
 
2135
        return self._initialize_helper(a_bzrdir, utf8_files, name, repository)
2068
2136
 
2069
2137
    def make_tags(self, branch):
2070
2138
        """See bzrlib.branch.BranchFormat.make_tags()."""
2088
2156
        """See BranchFormat.get_format_description()."""
2089
2157
        return "Branch format 8"
2090
2158
 
2091
 
    def initialize(self, a_bzrdir, name=None):
 
2159
    def initialize(self, a_bzrdir, name=None, repository=None):
2092
2160
        """Create a branch of this format in a_bzrdir."""
2093
2161
        utf8_files = [('last-revision', '0 null:\n'),
2094
2162
                      ('branch.conf', ''),
2095
2163
                      ('tags', ''),
2096
2164
                      ('references', '')
2097
2165
                      ]
2098
 
        return self._initialize_helper(a_bzrdir, utf8_files, name)
2099
 
 
2100
 
    def __init__(self):
2101
 
        super(BzrBranchFormat8, self).__init__()
2102
 
        self._matchingbzrdir.repository_format = \
2103
 
            RepositoryFormatKnitPack5RichRoot()
 
2166
        return self._initialize_helper(a_bzrdir, utf8_files, name, repository)
2104
2167
 
2105
2168
    def make_tags(self, branch):
2106
2169
        """See bzrlib.branch.BranchFormat.make_tags()."""
2115
2178
    supports_reference_locations = True
2116
2179
 
2117
2180
 
2118
 
class BzrBranchFormat7(BzrBranchFormat8):
 
2181
class BzrBranchFormat7(BranchFormatMetadir):
2119
2182
    """Branch format with last-revision, tags, and a stacked location pointer.
2120
2183
 
2121
2184
    The stacked location pointer is passed down to the repository and requires
2124
2187
    This format was introduced in bzr 1.6.
2125
2188
    """
2126
2189
 
2127
 
    def initialize(self, a_bzrdir, name=None):
 
2190
    def initialize(self, a_bzrdir, name=None, repository=None):
2128
2191
        """Create a branch of this format in a_bzrdir."""
2129
2192
        utf8_files = [('last-revision', '0 null:\n'),
2130
2193
                      ('branch.conf', ''),
2131
2194
                      ('tags', ''),
2132
2195
                      ]
2133
 
        return self._initialize_helper(a_bzrdir, utf8_files, name)
 
2196
        return self._initialize_helper(a_bzrdir, utf8_files, name, repository)
2134
2197
 
2135
2198
    def _branch_class(self):
2136
2199
        return BzrBranch7
2146
2209
    def supports_set_append_revisions_only(self):
2147
2210
        return True
2148
2211
 
 
2212
    def supports_stacking(self):
 
2213
        return True
 
2214
 
 
2215
    def make_tags(self, branch):
 
2216
        """See bzrlib.branch.BranchFormat.make_tags()."""
 
2217
        return BasicTags(branch)
 
2218
 
2149
2219
    supports_reference_locations = False
2150
2220
 
2151
2221
 
2168
2238
        """See BranchFormat.get_format_description()."""
2169
2239
        return "Checkout reference format 1"
2170
2240
 
2171
 
    def get_reference(self, a_bzrdir):
 
2241
    def get_reference(self, a_bzrdir, name=None):
2172
2242
        """See BranchFormat.get_reference()."""
2173
 
        transport = a_bzrdir.get_branch_transport(None)
 
2243
        transport = a_bzrdir.get_branch_transport(None, name=name)
2174
2244
        return transport.get_bytes('location')
2175
2245
 
2176
 
    def set_reference(self, a_bzrdir, to_branch):
 
2246
    def set_reference(self, a_bzrdir, name, to_branch):
2177
2247
        """See BranchFormat.set_reference()."""
2178
 
        transport = a_bzrdir.get_branch_transport(None)
 
2248
        transport = a_bzrdir.get_branch_transport(None, name=name)
2179
2249
        location = transport.put_bytes('location', to_branch.base)
2180
2250
 
2181
 
    def initialize(self, a_bzrdir, name=None, target_branch=None):
 
2251
    def initialize(self, a_bzrdir, name=None, target_branch=None,
 
2252
            repository=None):
2182
2253
        """Create a branch of this format in a_bzrdir."""
2183
2254
        if target_branch is None:
2184
2255
            # this format does not implement branch itself, thus the implicit
2212
2283
        return clone
2213
2284
 
2214
2285
    def open(self, a_bzrdir, name=None, _found=False, location=None,
2215
 
             possible_transports=None, ignore_fallbacks=False):
 
2286
             possible_transports=None, ignore_fallbacks=False,
 
2287
             found_repository=None):
2216
2288
        """Return the branch that the branch reference in a_bzrdir points at.
2217
2289
 
2218
2290
        :param a_bzrdir: A BzrDir that contains a branch.
2232
2304
                raise AssertionError("wrong format %r found for %r" %
2233
2305
                    (format, self))
2234
2306
        if location is None:
2235
 
            location = self.get_reference(a_bzrdir)
 
2307
            location = self.get_reference(a_bzrdir, name)
2236
2308
        real_bzrdir = bzrdir.BzrDir.open(
2237
2309
            location, possible_transports=possible_transports)
2238
2310
        result = real_bzrdir.open_branch(name=name, 
2249
2321
        return result
2250
2322
 
2251
2323
 
 
2324
class BranchFormatRegistry(controldir.ControlComponentFormatRegistry):
 
2325
    """Branch format registry."""
 
2326
 
 
2327
    def __init__(self, other_registry=None):
 
2328
        super(BranchFormatRegistry, self).__init__(other_registry)
 
2329
        self._default_format = None
 
2330
 
 
2331
    def set_default(self, format):
 
2332
        self._default_format = format
 
2333
 
 
2334
    def get_default(self):
 
2335
        return self._default_format
 
2336
 
 
2337
 
2252
2338
network_format_registry = registry.FormatRegistry()
2253
2339
"""Registry of formats indexed by their network name.
2254
2340
 
2257
2343
BranchFormat.network_name() for more detail.
2258
2344
"""
2259
2345
 
 
2346
format_registry = BranchFormatRegistry(network_format_registry)
 
2347
 
2260
2348
 
2261
2349
# formats which have no format string are not discoverable
2262
2350
# and not independently creatable, so are not registered.
2264
2352
__format6 = BzrBranchFormat6()
2265
2353
__format7 = BzrBranchFormat7()
2266
2354
__format8 = BzrBranchFormat8()
2267
 
BranchFormat.register_format(__format5)
2268
 
BranchFormat.register_format(BranchReferenceFormat())
2269
 
BranchFormat.register_format(__format6)
2270
 
BranchFormat.register_format(__format7)
2271
 
BranchFormat.register_format(__format8)
2272
 
BranchFormat.set_default_format(__format7)
2273
 
_legacy_formats = [BzrBranchFormat4(),
2274
 
    ]
2275
 
network_format_registry.register(
2276
 
    _legacy_formats[0].network_name(), _legacy_formats[0].__class__)
2277
 
 
2278
 
 
2279
 
class BranchWriteLockResult(object):
 
2355
format_registry.register(__format5)
 
2356
format_registry.register(BranchReferenceFormat())
 
2357
format_registry.register(__format6)
 
2358
format_registry.register(__format7)
 
2359
format_registry.register(__format8)
 
2360
format_registry.set_default(__format7)
 
2361
 
 
2362
 
 
2363
class BranchWriteLockResult(LogicalLockResult):
2280
2364
    """The result of write locking a branch.
2281
2365
 
2282
2366
    :ivar branch_token: The token obtained from the underlying branch lock, or
2285
2369
    """
2286
2370
 
2287
2371
    def __init__(self, unlock, branch_token):
 
2372
        LogicalLockResult.__init__(self, unlock)
2288
2373
        self.branch_token = branch_token
2289
 
        self.unlock = unlock
2290
2374
 
2291
 
    def __str__(self):
 
2375
    def __repr__(self):
2292
2376
        return "BranchWriteLockResult(%s, %s)" % (self.branch_token,
2293
2377
            self.unlock)
2294
2378
 
2379
2463
    def lock_read(self):
2380
2464
        """Lock the branch for read operations.
2381
2465
 
2382
 
        :return: An object with an unlock method which will release the lock
2383
 
            obtained.
 
2466
        :return: A bzrlib.lock.LogicalLockResult.
2384
2467
        """
2385
2468
        if not self.is_locked():
2386
2469
            self._note_lock('r')
2394
2477
            took_lock = False
2395
2478
        try:
2396
2479
            self.control_files.lock_read()
2397
 
            return self
 
2480
            return LogicalLockResult(self.unlock)
2398
2481
        except:
2399
2482
            if took_lock:
2400
2483
                self.repository.unlock()
2428
2511
        """See Branch.print_file."""
2429
2512
        return self.repository.print_file(file, revision_id)
2430
2513
 
2431
 
    def _write_revision_history(self, history):
2432
 
        """Factored out of set_revision_history.
2433
 
 
2434
 
        This performs the actual writing to disk.
2435
 
        It is intended to be called by BzrBranch5.set_revision_history."""
2436
 
        self._transport.put_bytes(
2437
 
            'revision-history', '\n'.join(history),
2438
 
            mode=self.bzrdir._get_file_mode())
2439
 
 
2440
 
    @needs_write_lock
2441
 
    def set_revision_history(self, rev_history):
2442
 
        """See Branch.set_revision_history."""
2443
 
        if 'evil' in debug.debug_flags:
2444
 
            mutter_callsite(3, "set_revision_history scales with history.")
2445
 
        check_not_reserved_id = _mod_revision.check_not_reserved_id
2446
 
        for rev_id in rev_history:
2447
 
            check_not_reserved_id(rev_id)
2448
 
        if Branch.hooks['post_change_branch_tip']:
2449
 
            # Don't calculate the last_revision_info() if there are no hooks
2450
 
            # that will use it.
2451
 
            old_revno, old_revid = self.last_revision_info()
2452
 
        if len(rev_history) == 0:
2453
 
            revid = _mod_revision.NULL_REVISION
2454
 
        else:
2455
 
            revid = rev_history[-1]
2456
 
        self._run_pre_change_branch_tip_hooks(len(rev_history), revid)
2457
 
        self._write_revision_history(rev_history)
2458
 
        self._clear_cached_state()
2459
 
        self._cache_revision_history(rev_history)
2460
 
        for hook in Branch.hooks['set_rh']:
2461
 
            hook(self, rev_history)
2462
 
        if Branch.hooks['post_change_branch_tip']:
2463
 
            self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2464
 
 
2465
 
    def _synchronize_history(self, destination, revision_id):
2466
 
        """Synchronize last revision and revision history between branches.
2467
 
 
2468
 
        This version is most efficient when the destination is also a
2469
 
        BzrBranch5, but works for BzrBranch6 as long as the revision
2470
 
        history is the true lefthand parent history, and all of the revisions
2471
 
        are in the destination's repository.  If not, set_revision_history
2472
 
        will fail.
2473
 
 
2474
 
        :param destination: The branch to copy the history into
2475
 
        :param revision_id: The revision-id to truncate history at.  May
2476
 
          be None to copy complete history.
2477
 
        """
2478
 
        if not isinstance(destination._format, BzrBranchFormat5):
2479
 
            super(BzrBranch, self)._synchronize_history(
2480
 
                destination, revision_id)
2481
 
            return
2482
 
        if revision_id == _mod_revision.NULL_REVISION:
2483
 
            new_history = []
2484
 
        else:
2485
 
            new_history = self.revision_history()
2486
 
        if revision_id is not None and new_history != []:
2487
 
            try:
2488
 
                new_history = new_history[:new_history.index(revision_id) + 1]
2489
 
            except ValueError:
2490
 
                rev = self.repository.get_revision(revision_id)
2491
 
                new_history = rev.get_history(self.repository)[1:]
2492
 
        destination.set_revision_history(new_history)
2493
 
 
2494
2514
    @needs_write_lock
2495
2515
    def set_last_revision_info(self, revno, revision_id):
2496
 
        """Set the last revision of this branch.
2497
 
 
2498
 
        The caller is responsible for checking that the revno is correct
2499
 
        for this revision id.
2500
 
 
2501
 
        It may be possible to set the branch last revision to an id not
2502
 
        present in the repository.  However, branches can also be
2503
 
        configured to check constraints on history, in which case this may not
2504
 
        be permitted.
2505
 
        """
 
2516
        if not revision_id or not isinstance(revision_id, basestring):
 
2517
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2506
2518
        revision_id = _mod_revision.ensure_null(revision_id)
2507
 
        # this old format stores the full history, but this api doesn't
2508
 
        # provide it, so we must generate, and might as well check it's
2509
 
        # correct
2510
 
        history = self._lefthand_history(revision_id)
2511
 
        if len(history) != revno:
2512
 
            raise AssertionError('%d != %d' % (len(history), revno))
2513
 
        self.set_revision_history(history)
2514
 
 
2515
 
    def _gen_revision_history(self):
2516
 
        history = self._transport.get_bytes('revision-history').split('\n')
2517
 
        if history[-1:] == ['']:
2518
 
            # There shouldn't be a trailing newline, but just in case.
2519
 
            history.pop()
2520
 
        return history
2521
 
 
2522
 
    @needs_write_lock
2523
 
    def generate_revision_history(self, revision_id, last_rev=None,
2524
 
        other_branch=None):
2525
 
        """Create a new revision history that will finish with revision_id.
2526
 
 
2527
 
        :param revision_id: the new tip to use.
2528
 
        :param last_rev: The previous last_revision. If not None, then this
2529
 
            must be a ancestory of revision_id, or DivergedBranches is raised.
2530
 
        :param other_branch: The other branch that DivergedBranches should
2531
 
            raise with respect to.
2532
 
        """
2533
 
        self.set_revision_history(self._lefthand_history(revision_id,
2534
 
            last_rev, other_branch))
 
2519
        old_revno, old_revid = self.last_revision_info()
 
2520
        if self._get_append_revisions_only():
 
2521
            self._check_history_violation(revision_id)
 
2522
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
 
2523
        self._write_last_revision_info(revno, revision_id)
 
2524
        self._clear_cached_state()
 
2525
        self._last_revision_info_cache = revno, revision_id
 
2526
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2535
2527
 
2536
2528
    def basis_tree(self):
2537
2529
        """See Branch.basis_tree."""
2546
2538
                pass
2547
2539
        return None
2548
2540
 
2549
 
    def _basic_push(self, target, overwrite, stop_revision):
2550
 
        """Basic implementation of push without bound branches or hooks.
2551
 
 
2552
 
        Must be called with source read locked and target write locked.
2553
 
        """
2554
 
        result = BranchPushResult()
2555
 
        result.source_branch = self
2556
 
        result.target_branch = target
2557
 
        result.old_revno, result.old_revid = target.last_revision_info()
2558
 
        self.update_references(target)
2559
 
        if result.old_revid != self.last_revision():
2560
 
            # We assume that during 'push' this repository is closer than
2561
 
            # the target.
2562
 
            graph = self.repository.get_graph(target.repository)
2563
 
            target.update_revisions(self, stop_revision,
2564
 
                overwrite=overwrite, graph=graph)
2565
 
        if self._push_should_merge_tags():
2566
 
            result.tag_conflicts = self.tags.merge_to(target.tags,
2567
 
                overwrite)
2568
 
        result.new_revno, result.new_revid = target.last_revision_info()
2569
 
        return result
2570
 
 
2571
2541
    def get_stacked_on_url(self):
2572
2542
        raise errors.UnstackableBranchFormat(self._format, self.user_url)
2573
2543
 
2584
2554
            self._transport.put_bytes('parent', url + '\n',
2585
2555
                mode=self.bzrdir._get_file_mode())
2586
2556
 
2587
 
 
2588
 
class BzrBranch5(BzrBranch):
2589
 
    """A format 5 branch. This supports new features over plain branches.
2590
 
 
2591
 
    It has support for a master_branch which is the data for bound branches.
2592
 
    """
2593
 
 
2594
 
    def get_bound_location(self):
2595
 
        try:
2596
 
            return self._transport.get_bytes('bound')[:-1]
2597
 
        except errors.NoSuchFile:
2598
 
            return None
2599
 
 
2600
 
    @needs_read_lock
2601
 
    def get_master_branch(self, possible_transports=None):
2602
 
        """Return the branch we are bound to.
2603
 
 
2604
 
        :return: Either a Branch, or None
2605
 
 
2606
 
        This could memoise the branch, but if thats done
2607
 
        it must be revalidated on each new lock.
2608
 
        So for now we just don't memoise it.
2609
 
        # RBC 20060304 review this decision.
2610
 
        """
2611
 
        bound_loc = self.get_bound_location()
2612
 
        if not bound_loc:
2613
 
            return None
2614
 
        try:
2615
 
            return Branch.open(bound_loc,
2616
 
                               possible_transports=possible_transports)
2617
 
        except (errors.NotBranchError, errors.ConnectionError), e:
2618
 
            raise errors.BoundBranchConnectionFailure(
2619
 
                    self, bound_loc, e)
2620
 
 
2621
2557
    @needs_write_lock
2622
 
    def set_bound_location(self, location):
2623
 
        """Set the target where this branch is bound to.
2624
 
 
2625
 
        :param location: URL to the target branch
2626
 
        """
2627
 
        if location:
2628
 
            self._transport.put_bytes('bound', location+'\n',
2629
 
                mode=self.bzrdir._get_file_mode())
2630
 
        else:
2631
 
            try:
2632
 
                self._transport.delete('bound')
2633
 
            except errors.NoSuchFile:
2634
 
                return False
2635
 
            return True
 
2558
    def unbind(self):
 
2559
        """If bound, unbind"""
 
2560
        return self.set_bound_location(None)
2636
2561
 
2637
2562
    @needs_write_lock
2638
2563
    def bind(self, other):
2660
2585
        # history around
2661
2586
        self.set_bound_location(other.base)
2662
2587
 
 
2588
    def get_bound_location(self):
 
2589
        try:
 
2590
            return self._transport.get_bytes('bound')[:-1]
 
2591
        except errors.NoSuchFile:
 
2592
            return None
 
2593
 
 
2594
    @needs_read_lock
 
2595
    def get_master_branch(self, possible_transports=None):
 
2596
        """Return the branch we are bound to.
 
2597
 
 
2598
        :return: Either a Branch, or None
 
2599
        """
 
2600
        if self._master_branch_cache is None:
 
2601
            self._master_branch_cache = self._get_master_branch(
 
2602
                possible_transports)
 
2603
        return self._master_branch_cache
 
2604
 
 
2605
    def _get_master_branch(self, possible_transports):
 
2606
        bound_loc = self.get_bound_location()
 
2607
        if not bound_loc:
 
2608
            return None
 
2609
        try:
 
2610
            return Branch.open(bound_loc,
 
2611
                               possible_transports=possible_transports)
 
2612
        except (errors.NotBranchError, errors.ConnectionError), e:
 
2613
            raise errors.BoundBranchConnectionFailure(
 
2614
                    self, bound_loc, e)
 
2615
 
2663
2616
    @needs_write_lock
2664
 
    def unbind(self):
2665
 
        """If bound, unbind"""
2666
 
        return self.set_bound_location(None)
 
2617
    def set_bound_location(self, location):
 
2618
        """Set the target where this branch is bound to.
 
2619
 
 
2620
        :param location: URL to the target branch
 
2621
        """
 
2622
        self._master_branch_cache = None
 
2623
        if location:
 
2624
            self._transport.put_bytes('bound', location+'\n',
 
2625
                mode=self.bzrdir._get_file_mode())
 
2626
        else:
 
2627
            try:
 
2628
                self._transport.delete('bound')
 
2629
            except errors.NoSuchFile:
 
2630
                return False
 
2631
            return True
2667
2632
 
2668
2633
    @needs_write_lock
2669
2634
    def update(self, possible_transports=None):
2682
2647
            return old_tip
2683
2648
        return None
2684
2649
 
2685
 
 
2686
 
class BzrBranch8(BzrBranch5):
 
2650
    def _read_last_revision_info(self):
 
2651
        revision_string = self._transport.get_bytes('last-revision')
 
2652
        revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
 
2653
        revision_id = cache_utf8.get_cached_utf8(revision_id)
 
2654
        revno = int(revno)
 
2655
        return revno, revision_id
 
2656
 
 
2657
    def _write_last_revision_info(self, revno, revision_id):
 
2658
        """Simply write out the revision id, with no checks.
 
2659
 
 
2660
        Use set_last_revision_info to perform this safely.
 
2661
 
 
2662
        Does not update the revision_history cache.
 
2663
        """
 
2664
        revision_id = _mod_revision.ensure_null(revision_id)
 
2665
        out_string = '%d %s\n' % (revno, revision_id)
 
2666
        self._transport.put_bytes('last-revision', out_string,
 
2667
            mode=self.bzrdir._get_file_mode())
 
2668
 
 
2669
 
 
2670
class FullHistoryBzrBranch(BzrBranch):
 
2671
    """Bzr branch which contains the full revision history."""
 
2672
 
 
2673
    @needs_write_lock
 
2674
    def set_last_revision_info(self, revno, revision_id):
 
2675
        if not revision_id or not isinstance(revision_id, basestring):
 
2676
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
 
2677
        revision_id = _mod_revision.ensure_null(revision_id)
 
2678
        # this old format stores the full history, but this api doesn't
 
2679
        # provide it, so we must generate, and might as well check it's
 
2680
        # correct
 
2681
        history = self._lefthand_history(revision_id)
 
2682
        if len(history) != revno:
 
2683
            raise AssertionError('%d != %d' % (len(history), revno))
 
2684
        self._set_revision_history(history)
 
2685
 
 
2686
    def _read_last_revision_info(self):
 
2687
        rh = self.revision_history()
 
2688
        revno = len(rh)
 
2689
        if revno:
 
2690
            return (revno, rh[-1])
 
2691
        else:
 
2692
            return (0, _mod_revision.NULL_REVISION)
 
2693
 
 
2694
    @deprecated_method(deprecated_in((2, 4, 0)))
 
2695
    @needs_write_lock
 
2696
    def set_revision_history(self, rev_history):
 
2697
        """See Branch.set_revision_history."""
 
2698
        self._set_revision_history(rev_history)
 
2699
 
 
2700
    def _set_revision_history(self, rev_history):
 
2701
        if 'evil' in debug.debug_flags:
 
2702
            mutter_callsite(3, "set_revision_history scales with history.")
 
2703
        check_not_reserved_id = _mod_revision.check_not_reserved_id
 
2704
        for rev_id in rev_history:
 
2705
            check_not_reserved_id(rev_id)
 
2706
        if Branch.hooks['post_change_branch_tip']:
 
2707
            # Don't calculate the last_revision_info() if there are no hooks
 
2708
            # that will use it.
 
2709
            old_revno, old_revid = self.last_revision_info()
 
2710
        if len(rev_history) == 0:
 
2711
            revid = _mod_revision.NULL_REVISION
 
2712
        else:
 
2713
            revid = rev_history[-1]
 
2714
        self._run_pre_change_branch_tip_hooks(len(rev_history), revid)
 
2715
        self._write_revision_history(rev_history)
 
2716
        self._clear_cached_state()
 
2717
        self._cache_revision_history(rev_history)
 
2718
        for hook in Branch.hooks['set_rh']:
 
2719
            hook(self, rev_history)
 
2720
        if Branch.hooks['post_change_branch_tip']:
 
2721
            self._run_post_change_branch_tip_hooks(old_revno, old_revid)
 
2722
 
 
2723
    def _write_revision_history(self, history):
 
2724
        """Factored out of set_revision_history.
 
2725
 
 
2726
        This performs the actual writing to disk.
 
2727
        It is intended to be called by set_revision_history."""
 
2728
        self._transport.put_bytes(
 
2729
            'revision-history', '\n'.join(history),
 
2730
            mode=self.bzrdir._get_file_mode())
 
2731
 
 
2732
    def _gen_revision_history(self):
 
2733
        history = self._transport.get_bytes('revision-history').split('\n')
 
2734
        if history[-1:] == ['']:
 
2735
            # There shouldn't be a trailing newline, but just in case.
 
2736
            history.pop()
 
2737
        return history
 
2738
 
 
2739
    def _synchronize_history(self, destination, revision_id):
 
2740
        if not isinstance(destination, FullHistoryBzrBranch):
 
2741
            super(BzrBranch, self)._synchronize_history(
 
2742
                destination, revision_id)
 
2743
            return
 
2744
        if revision_id == _mod_revision.NULL_REVISION:
 
2745
            new_history = []
 
2746
        else:
 
2747
            new_history = self.revision_history()
 
2748
        if revision_id is not None and new_history != []:
 
2749
            try:
 
2750
                new_history = new_history[:new_history.index(revision_id) + 1]
 
2751
            except ValueError:
 
2752
                rev = self.repository.get_revision(revision_id)
 
2753
                new_history = rev.get_history(self.repository)[1:]
 
2754
        destination._set_revision_history(new_history)
 
2755
 
 
2756
    @needs_write_lock
 
2757
    def generate_revision_history(self, revision_id, last_rev=None,
 
2758
        other_branch=None):
 
2759
        """Create a new revision history that will finish with revision_id.
 
2760
 
 
2761
        :param revision_id: the new tip to use.
 
2762
        :param last_rev: The previous last_revision. If not None, then this
 
2763
            must be a ancestory of revision_id, or DivergedBranches is raised.
 
2764
        :param other_branch: The other branch that DivergedBranches should
 
2765
            raise with respect to.
 
2766
        """
 
2767
        self._set_revision_history(self._lefthand_history(revision_id,
 
2768
            last_rev, other_branch))
 
2769
 
 
2770
 
 
2771
class BzrBranch5(FullHistoryBzrBranch):
 
2772
    """A format 5 branch. This supports new features over plain branches.
 
2773
 
 
2774
    It has support for a master_branch which is the data for bound branches.
 
2775
    """
 
2776
 
 
2777
 
 
2778
class BzrBranch8(BzrBranch):
2687
2779
    """A branch that stores tree-reference locations."""
2688
2780
 
2689
2781
    def _open_hook(self):
2715
2807
        self._last_revision_info_cache = None
2716
2808
        self._reference_info = None
2717
2809
 
2718
 
    def _last_revision_info(self):
2719
 
        revision_string = self._transport.get_bytes('last-revision')
2720
 
        revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
2721
 
        revision_id = cache_utf8.get_cached_utf8(revision_id)
2722
 
        revno = int(revno)
2723
 
        return revno, revision_id
2724
 
 
2725
 
    def _write_last_revision_info(self, revno, revision_id):
2726
 
        """Simply write out the revision id, with no checks.
2727
 
 
2728
 
        Use set_last_revision_info to perform this safely.
2729
 
 
2730
 
        Does not update the revision_history cache.
2731
 
        Intended to be called by set_last_revision_info and
2732
 
        _write_revision_history.
2733
 
        """
2734
 
        revision_id = _mod_revision.ensure_null(revision_id)
2735
 
        out_string = '%d %s\n' % (revno, revision_id)
2736
 
        self._transport.put_bytes('last-revision', out_string,
2737
 
            mode=self.bzrdir._get_file_mode())
2738
 
 
2739
 
    @needs_write_lock
2740
 
    def set_last_revision_info(self, revno, revision_id):
2741
 
        revision_id = _mod_revision.ensure_null(revision_id)
2742
 
        old_revno, old_revid = self.last_revision_info()
2743
 
        if self._get_append_revisions_only():
2744
 
            self._check_history_violation(revision_id)
2745
 
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
2746
 
        self._write_last_revision_info(revno, revision_id)
2747
 
        self._clear_cached_state()
2748
 
        self._last_revision_info_cache = revno, revision_id
2749
 
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2750
 
 
2751
 
    def _synchronize_history(self, destination, revision_id):
2752
 
        """Synchronize last revision and revision history between branches.
2753
 
 
2754
 
        :see: Branch._synchronize_history
2755
 
        """
2756
 
        # XXX: The base Branch has a fast implementation of this method based
2757
 
        # on set_last_revision_info, but BzrBranch/BzrBranch5 have a slower one
2758
 
        # that uses set_revision_history.  This class inherits from BzrBranch5,
2759
 
        # but wants the fast implementation, so it calls
2760
 
        # Branch._synchronize_history directly.
2761
 
        Branch._synchronize_history(self, destination, revision_id)
2762
 
 
2763
2810
    def _check_history_violation(self, revision_id):
2764
2811
        last_revision = _mod_revision.ensure_null(self.last_revision())
2765
2812
        if _mod_revision.is_null(last_revision):
2774
2821
        self._extend_partial_history(stop_index=last_revno-1)
2775
2822
        return list(reversed(self._partial_revision_history_cache))
2776
2823
 
2777
 
    def _write_revision_history(self, history):
2778
 
        """Factored out of set_revision_history.
2779
 
 
2780
 
        This performs the actual writing to disk, with format-specific checks.
2781
 
        It is intended to be called by BzrBranch5.set_revision_history.
2782
 
        """
2783
 
        if len(history) == 0:
2784
 
            last_revision = 'null:'
2785
 
        else:
2786
 
            if history != self._lefthand_history(history[-1]):
2787
 
                raise errors.NotLefthandHistory(history)
2788
 
            last_revision = history[-1]
2789
 
        if self._get_append_revisions_only():
2790
 
            self._check_history_violation(last_revision)
2791
 
        self._write_last_revision_info(len(history), last_revision)
2792
 
 
2793
2824
    @needs_write_lock
2794
2825
    def _set_parent_location(self, url):
2795
2826
        """Set the parent branch"""
2881
2912
 
2882
2913
    def set_bound_location(self, location):
2883
2914
        """See Branch.set_push_location."""
 
2915
        self._master_branch_cache = None
2884
2916
        result = None
2885
2917
        config = self.get_config()
2886
2918
        if location is None:
2926
2958
        return self.get_config(
2927
2959
            ).get_user_option_as_bool('append_revisions_only')
2928
2960
 
2929
 
    @needs_write_lock
2930
 
    def generate_revision_history(self, revision_id, last_rev=None,
2931
 
                                  other_branch=None):
2932
 
        """See BzrBranch5.generate_revision_history"""
2933
 
        history = self._lefthand_history(revision_id, last_rev, other_branch)
2934
 
        revno = len(history)
2935
 
        self.set_last_revision_info(revno, revision_id)
2936
 
 
2937
2961
    @needs_read_lock
2938
2962
    def get_rev_id(self, revno, history=None):
2939
2963
        """Find the revision id of the specified revno."""
2963
2987
        try:
2964
2988
            index = self._partial_revision_history_cache.index(revision_id)
2965
2989
        except ValueError:
2966
 
            self._extend_partial_history(stop_revision=revision_id)
 
2990
            try:
 
2991
                self._extend_partial_history(stop_revision=revision_id)
 
2992
            except errors.RevisionNotPresent, e:
 
2993
                raise errors.GhostRevisionsHaveNoRevno(revision_id, e.revision_id)
2967
2994
            index = len(self._partial_revision_history_cache) - 1
2968
2995
            if self._partial_revision_history_cache[index] != revision_id:
2969
2996
                raise errors.NoSuchRevision(self, revision_id)
3024
3051
    :ivar tag_conflicts: A list of tag conflicts, see BasicTags.merge_to
3025
3052
    """
3026
3053
 
 
3054
    @deprecated_method(deprecated_in((2, 3, 0)))
3027
3055
    def __int__(self):
3028
 
        # DEPRECATED: pull used to return the change in revno
 
3056
        """Return the relative change in revno.
 
3057
 
 
3058
        :deprecated: Use `new_revno` and `old_revno` instead.
 
3059
        """
3029
3060
        return self.new_revno - self.old_revno
3030
3061
 
3031
3062
    def report(self, to_file):
3056
3087
        target, otherwise it will be None.
3057
3088
    """
3058
3089
 
 
3090
    @deprecated_method(deprecated_in((2, 3, 0)))
3059
3091
    def __int__(self):
3060
 
        # DEPRECATED: push used to return the change in revno
 
3092
        """Return the relative change in revno.
 
3093
 
 
3094
        :deprecated: Use `new_revno` and `old_revno` instead.
 
3095
        """
3061
3096
        return self.new_revno - self.old_revno
3062
3097
 
3063
3098
    def report(self, to_file):
3186
3221
    _optimisers = []
3187
3222
    """The available optimised InterBranch types."""
3188
3223
 
3189
 
    @staticmethod
3190
 
    def _get_branch_formats_to_test():
3191
 
        """Return a tuple with the Branch formats to use when testing."""
3192
 
        raise NotImplementedError(InterBranch._get_branch_formats_to_test)
 
3224
    @classmethod
 
3225
    def _get_branch_formats_to_test(klass):
 
3226
        """Return an iterable of format tuples for testing.
 
3227
        
 
3228
        :return: An iterable of (from_format, to_format) to use when testing
 
3229
            this InterBranch class. Each InterBranch class should define this
 
3230
            method itself.
 
3231
        """
 
3232
        raise NotImplementedError(klass._get_branch_formats_to_test)
3193
3233
 
 
3234
    @needs_write_lock
3194
3235
    def pull(self, overwrite=False, stop_revision=None,
3195
3236
             possible_transports=None, local=False):
3196
3237
        """Mirror source into target branch.
3201
3242
        """
3202
3243
        raise NotImplementedError(self.pull)
3203
3244
 
3204
 
    def update_revisions(self, stop_revision=None, overwrite=False,
3205
 
                         graph=None):
3206
 
        """Pull in new perfect-fit revisions.
3207
 
 
3208
 
        :param stop_revision: Updated until the given revision
3209
 
        :param overwrite: Always set the branch pointer, rather than checking
3210
 
            to see if it is a proper descendant.
3211
 
        :param graph: A Graph object that can be used to query history
3212
 
            information. This can be None.
3213
 
        :return: None
3214
 
        """
3215
 
        raise NotImplementedError(self.update_revisions)
3216
 
 
 
3245
    @needs_write_lock
3217
3246
    def push(self, overwrite=False, stop_revision=None,
3218
3247
             _override_hook_source_branch=None):
3219
3248
        """Mirror the source branch into the target branch.
3222
3251
        """
3223
3252
        raise NotImplementedError(self.push)
3224
3253
 
 
3254
    @needs_write_lock
 
3255
    def copy_content_into(self, revision_id=None):
 
3256
        """Copy the content of source into target
 
3257
 
 
3258
        revision_id: if not None, the revision history in the new branch will
 
3259
                     be truncated to end with revision_id.
 
3260
        """
 
3261
        raise NotImplementedError(self.copy_content_into)
 
3262
 
 
3263
    @needs_write_lock
 
3264
    def fetch(self, stop_revision=None):
 
3265
        """Fetch revisions.
 
3266
 
 
3267
        :param stop_revision: Last revision to fetch
 
3268
        """
 
3269
        raise NotImplementedError(self.fetch)
 
3270
 
3225
3271
 
3226
3272
class GenericInterBranch(InterBranch):
3227
 
    """InterBranch implementation that uses public Branch functions.
3228
 
    """
3229
 
 
3230
 
    @staticmethod
3231
 
    def _get_branch_formats_to_test():
3232
 
        return BranchFormat._default_format, BranchFormat._default_format
3233
 
 
3234
 
    def update_revisions(self, stop_revision=None, overwrite=False,
3235
 
        graph=None):
3236
 
        """See InterBranch.update_revisions()."""
 
3273
    """InterBranch implementation that uses public Branch functions."""
 
3274
 
 
3275
    @classmethod
 
3276
    def is_compatible(klass, source, target):
 
3277
        # GenericBranch uses the public API, so always compatible
 
3278
        return True
 
3279
 
 
3280
    @classmethod
 
3281
    def _get_branch_formats_to_test(klass):
 
3282
        return [(format_registry.get_default(), format_registry.get_default())]
 
3283
 
 
3284
    @classmethod
 
3285
    def unwrap_format(klass, format):
 
3286
        if isinstance(format, remote.RemoteBranchFormat):
 
3287
            format._ensure_real()
 
3288
            return format._custom_format
 
3289
        return format
 
3290
 
 
3291
    @needs_write_lock
 
3292
    def copy_content_into(self, revision_id=None):
 
3293
        """Copy the content of source into target
 
3294
 
 
3295
        revision_id: if not None, the revision history in the new branch will
 
3296
                     be truncated to end with revision_id.
 
3297
        """
 
3298
        self.source.update_references(self.target)
 
3299
        self.source._synchronize_history(self.target, revision_id)
 
3300
        try:
 
3301
            parent = self.source.get_parent()
 
3302
        except errors.InaccessibleParent, e:
 
3303
            mutter('parent was not accessible to copy: %s', e)
 
3304
        else:
 
3305
            if parent:
 
3306
                self.target.set_parent(parent)
 
3307
        if self.source._push_should_merge_tags():
 
3308
            self.source.tags.merge_to(self.target.tags)
 
3309
 
 
3310
    @needs_write_lock
 
3311
    def fetch(self, stop_revision=None):
 
3312
        if self.target.base == self.source.base:
 
3313
            return (0, [])
3237
3314
        self.source.lock_read()
3238
3315
        try:
3239
 
            other_revno, other_last_revision = self.source.last_revision_info()
3240
 
            stop_revno = None # unknown
3241
 
            if stop_revision is None:
3242
 
                stop_revision = other_last_revision
3243
 
                if _mod_revision.is_null(stop_revision):
3244
 
                    # if there are no commits, we're done.
3245
 
                    return
3246
 
                stop_revno = other_revno
3247
 
 
3248
 
            # what's the current last revision, before we fetch [and change it
3249
 
            # possibly]
3250
 
            last_rev = _mod_revision.ensure_null(self.target.last_revision())
3251
 
            # we fetch here so that we don't process data twice in the common
3252
 
            # case of having something to pull, and so that the check for
3253
 
            # already merged can operate on the just fetched graph, which will
3254
 
            # be cached in memory.
3255
 
            self.target.fetch(self.source, stop_revision)
3256
 
            # Check to see if one is an ancestor of the other
3257
 
            if not overwrite:
3258
 
                if graph is None:
3259
 
                    graph = self.target.repository.get_graph()
3260
 
                if self.target._check_if_descendant_or_diverged(
3261
 
                        stop_revision, last_rev, graph, self.source):
3262
 
                    # stop_revision is a descendant of last_rev, but we aren't
3263
 
                    # overwriting, so we're done.
3264
 
                    return
3265
 
            if stop_revno is None:
3266
 
                if graph is None:
3267
 
                    graph = self.target.repository.get_graph()
3268
 
                this_revno, this_last_revision = \
3269
 
                        self.target.last_revision_info()
3270
 
                stop_revno = graph.find_distance_to_null(stop_revision,
3271
 
                                [(other_last_revision, other_revno),
3272
 
                                 (this_last_revision, this_revno)])
3273
 
            self.target.set_last_revision_info(stop_revno, stop_revision)
 
3316
            fetch_spec_factory = fetch.FetchSpecFactory()
 
3317
            fetch_spec_factory.source_branch = self.source
 
3318
            fetch_spec_factory.source_branch_stop_revision_id = stop_revision
 
3319
            fetch_spec_factory.source_repo = self.source.repository
 
3320
            fetch_spec_factory.target_repo = self.target.repository
 
3321
            fetch_spec_factory.target_repo_kind = fetch.TargetRepoKinds.PREEXISTING
 
3322
            fetch_spec = fetch_spec_factory.make_fetch_spec()
 
3323
            return self.target.repository.fetch(self.source.repository,
 
3324
                fetch_spec=fetch_spec)
3274
3325
        finally:
3275
3326
            self.source.unlock()
3276
3327
 
 
3328
    @needs_write_lock
 
3329
    def _update_revisions(self, stop_revision=None, overwrite=False,
 
3330
            graph=None):
 
3331
        other_revno, other_last_revision = self.source.last_revision_info()
 
3332
        stop_revno = None # unknown
 
3333
        if stop_revision is None:
 
3334
            stop_revision = other_last_revision
 
3335
            if _mod_revision.is_null(stop_revision):
 
3336
                # if there are no commits, we're done.
 
3337
                return
 
3338
            stop_revno = other_revno
 
3339
 
 
3340
        # what's the current last revision, before we fetch [and change it
 
3341
        # possibly]
 
3342
        last_rev = _mod_revision.ensure_null(self.target.last_revision())
 
3343
        # we fetch here so that we don't process data twice in the common
 
3344
        # case of having something to pull, and so that the check for
 
3345
        # already merged can operate on the just fetched graph, which will
 
3346
        # be cached in memory.
 
3347
        self.fetch(stop_revision=stop_revision)
 
3348
        # Check to see if one is an ancestor of the other
 
3349
        if not overwrite:
 
3350
            if graph is None:
 
3351
                graph = self.target.repository.get_graph()
 
3352
            if self.target._check_if_descendant_or_diverged(
 
3353
                    stop_revision, last_rev, graph, self.source):
 
3354
                # stop_revision is a descendant of last_rev, but we aren't
 
3355
                # overwriting, so we're done.
 
3356
                return
 
3357
        if stop_revno is None:
 
3358
            if graph is None:
 
3359
                graph = self.target.repository.get_graph()
 
3360
            this_revno, this_last_revision = \
 
3361
                    self.target.last_revision_info()
 
3362
            stop_revno = graph.find_distance_to_null(stop_revision,
 
3363
                            [(other_last_revision, other_revno),
 
3364
                             (this_last_revision, this_revno)])
 
3365
        self.target.set_last_revision_info(stop_revno, stop_revision)
 
3366
 
 
3367
    @needs_write_lock
3277
3368
    def pull(self, overwrite=False, stop_revision=None,
3278
 
             possible_transports=None, _hook_master=None, run_hooks=True,
 
3369
             possible_transports=None, run_hooks=True,
3279
3370
             _override_hook_target=None, local=False):
3280
 
        """See Branch.pull.
 
3371
        """Pull from source into self, updating my master if any.
3281
3372
 
3282
 
        :param _hook_master: Private parameter - set the branch to
3283
 
            be supplied as the master to pull hooks.
3284
3373
        :param run_hooks: Private parameter - if false, this branch
3285
3374
            is being called because it's the master of the primary branch,
3286
3375
            so it should not run its hooks.
3287
 
        :param _override_hook_target: Private parameter - set the branch to be
3288
 
            supplied as the target_branch to pull hooks.
3289
 
        :param local: Only update the local branch, and not the bound branch.
3290
3376
        """
3291
 
        # This type of branch can't be bound.
3292
 
        if local:
 
3377
        bound_location = self.target.get_bound_location()
 
3378
        if local and not bound_location:
3293
3379
            raise errors.LocalRequiresBoundBranch()
3294
 
        result = PullResult()
3295
 
        result.source_branch = self.source
3296
 
        if _override_hook_target is None:
3297
 
            result.target_branch = self.target
3298
 
        else:
3299
 
            result.target_branch = _override_hook_target
3300
 
        self.source.lock_read()
 
3380
        master_branch = None
 
3381
        source_is_master = (self.source.user_url == bound_location)
 
3382
        if not local and bound_location and not source_is_master:
 
3383
            # not pulling from master, so we need to update master.
 
3384
            master_branch = self.target.get_master_branch(possible_transports)
 
3385
            master_branch.lock_write()
3301
3386
        try:
3302
 
            # We assume that during 'pull' the target repository is closer than
3303
 
            # the source one.
3304
 
            self.source.update_references(self.target)
3305
 
            graph = self.target.repository.get_graph(self.source.repository)
3306
 
            # TODO: Branch formats should have a flag that indicates 
3307
 
            # that revno's are expensive, and pull() should honor that flag.
3308
 
            # -- JRV20090506
3309
 
            result.old_revno, result.old_revid = \
3310
 
                self.target.last_revision_info()
3311
 
            self.target.update_revisions(self.source, stop_revision,
3312
 
                overwrite=overwrite, graph=graph)
3313
 
            # TODO: The old revid should be specified when merging tags, 
3314
 
            # so a tags implementation that versions tags can only 
3315
 
            # pull in the most recent changes. -- JRV20090506
3316
 
            result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
3317
 
                overwrite)
3318
 
            result.new_revno, result.new_revid = self.target.last_revision_info()
3319
 
            if _hook_master:
3320
 
                result.master_branch = _hook_master
3321
 
                result.local_branch = result.target_branch
3322
 
            else:
3323
 
                result.master_branch = result.target_branch
3324
 
                result.local_branch = None
3325
 
            if run_hooks:
3326
 
                for hook in Branch.hooks['post_pull']:
3327
 
                    hook(result)
 
3387
            if master_branch:
 
3388
                # pull from source into master.
 
3389
                master_branch.pull(self.source, overwrite, stop_revision,
 
3390
                    run_hooks=False)
 
3391
            return self._pull(overwrite,
 
3392
                stop_revision, _hook_master=master_branch,
 
3393
                run_hooks=run_hooks,
 
3394
                _override_hook_target=_override_hook_target,
 
3395
                merge_tags_to_master=not source_is_master)
3328
3396
        finally:
3329
 
            self.source.unlock()
3330
 
        return result
 
3397
            if master_branch:
 
3398
                master_branch.unlock()
3331
3399
 
3332
3400
    def push(self, overwrite=False, stop_revision=None,
3333
3401
             _override_hook_source_branch=None):
3351
3419
        finally:
3352
3420
            self.source.unlock()
3353
3421
 
 
3422
    def _basic_push(self, overwrite, stop_revision):
 
3423
        """Basic implementation of push without bound branches or hooks.
 
3424
 
 
3425
        Must be called with source read locked and target write locked.
 
3426
        """
 
3427
        result = BranchPushResult()
 
3428
        result.source_branch = self.source
 
3429
        result.target_branch = self.target
 
3430
        result.old_revno, result.old_revid = self.target.last_revision_info()
 
3431
        self.source.update_references(self.target)
 
3432
        if result.old_revid != stop_revision:
 
3433
            # We assume that during 'push' this repository is closer than
 
3434
            # the target.
 
3435
            graph = self.source.repository.get_graph(self.target.repository)
 
3436
            self._update_revisions(stop_revision, overwrite=overwrite,
 
3437
                    graph=graph)
 
3438
        if self.source._push_should_merge_tags():
 
3439
            result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
 
3440
                overwrite)
 
3441
        result.new_revno, result.new_revid = self.target.last_revision_info()
 
3442
        return result
 
3443
 
3354
3444
    def _push_with_bound_branches(self, overwrite, stop_revision,
3355
3445
            _override_hook_source_branch=None):
3356
3446
        """Push from source into target, and into target's master if any.
3371
3461
            master_branch.lock_write()
3372
3462
            try:
3373
3463
                # push into the master from the source branch.
3374
 
                self.source._basic_push(master_branch, overwrite, stop_revision)
3375
 
                # and push into the target branch from the source. Note that we
3376
 
                # push from the source branch again, because its considered the
3377
 
                # highest bandwidth repository.
3378
 
                result = self.source._basic_push(self.target, overwrite,
3379
 
                    stop_revision)
 
3464
                master_inter = InterBranch.get(self.source, master_branch)
 
3465
                master_inter._basic_push(overwrite, stop_revision)
 
3466
                # and push into the target branch from the source. Note that
 
3467
                # we push from the source branch again, because it's considered
 
3468
                # the highest bandwidth repository.
 
3469
                result = self._basic_push(overwrite, stop_revision)
3380
3470
                result.master_branch = master_branch
3381
3471
                result.local_branch = self.target
3382
3472
                _run_hooks()
3385
3475
                master_branch.unlock()
3386
3476
        else:
3387
3477
            # no master branch
3388
 
            result = self.source._basic_push(self.target, overwrite,
3389
 
                stop_revision)
 
3478
            result = self._basic_push(overwrite, stop_revision)
3390
3479
            # TODO: Why set master_branch and local_branch if there's no
3391
3480
            # binding?  Maybe cleaner to just leave them unset? -- mbp
3392
3481
            # 20070504
3395
3484
            _run_hooks()
3396
3485
            return result
3397
3486
 
3398
 
    @classmethod
3399
 
    def is_compatible(self, source, target):
3400
 
        # GenericBranch uses the public API, so always compatible
3401
 
        return True
3402
 
 
3403
 
 
3404
 
class InterToBranch5(GenericInterBranch):
3405
 
 
3406
 
    @staticmethod
3407
 
    def _get_branch_formats_to_test():
3408
 
        return BranchFormat._default_format, BzrBranchFormat5()
3409
 
 
3410
 
    def pull(self, overwrite=False, stop_revision=None,
3411
 
             possible_transports=None, run_hooks=True,
3412
 
             _override_hook_target=None, local=False):
3413
 
        """Pull from source into self, updating my master if any.
3414
 
 
 
3487
    def _pull(self, overwrite=False, stop_revision=None,
 
3488
             possible_transports=None, _hook_master=None, run_hooks=True,
 
3489
             _override_hook_target=None, local=False,
 
3490
             merge_tags_to_master=True):
 
3491
        """See Branch.pull.
 
3492
 
 
3493
        This function is the core worker, used by GenericInterBranch.pull to
 
3494
        avoid duplication when pulling source->master and source->local.
 
3495
 
 
3496
        :param _hook_master: Private parameter - set the branch to
 
3497
            be supplied as the master to pull hooks.
3415
3498
        :param run_hooks: Private parameter - if false, this branch
3416
3499
            is being called because it's the master of the primary branch,
3417
3500
            so it should not run its hooks.
 
3501
            is being called because it's the master of the primary branch,
 
3502
            so it should not run its hooks.
 
3503
        :param _override_hook_target: Private parameter - set the branch to be
 
3504
            supplied as the target_branch to pull hooks.
 
3505
        :param local: Only update the local branch, and not the bound branch.
3418
3506
        """
3419
 
        bound_location = self.target.get_bound_location()
3420
 
        if local and not bound_location:
 
3507
        # This type of branch can't be bound.
 
3508
        if local:
3421
3509
            raise errors.LocalRequiresBoundBranch()
3422
 
        master_branch = None
3423
 
        if not local and bound_location and self.source.user_url != bound_location:
3424
 
            # not pulling from master, so we need to update master.
3425
 
            master_branch = self.target.get_master_branch(possible_transports)
3426
 
            master_branch.lock_write()
 
3510
        result = PullResult()
 
3511
        result.source_branch = self.source
 
3512
        if _override_hook_target is None:
 
3513
            result.target_branch = self.target
 
3514
        else:
 
3515
            result.target_branch = _override_hook_target
 
3516
        self.source.lock_read()
3427
3517
        try:
3428
 
            if master_branch:
3429
 
                # pull from source into master.
3430
 
                master_branch.pull(self.source, overwrite, stop_revision,
3431
 
                    run_hooks=False)
3432
 
            return super(InterToBranch5, self).pull(overwrite,
3433
 
                stop_revision, _hook_master=master_branch,
3434
 
                run_hooks=run_hooks,
3435
 
                _override_hook_target=_override_hook_target)
 
3518
            # We assume that during 'pull' the target repository is closer than
 
3519
            # the source one.
 
3520
            self.source.update_references(self.target)
 
3521
            graph = self.target.repository.get_graph(self.source.repository)
 
3522
            # TODO: Branch formats should have a flag that indicates 
 
3523
            # that revno's are expensive, and pull() should honor that flag.
 
3524
            # -- JRV20090506
 
3525
            result.old_revno, result.old_revid = \
 
3526
                self.target.last_revision_info()
 
3527
            self._update_revisions(stop_revision, overwrite=overwrite,
 
3528
                graph=graph)
 
3529
            # TODO: The old revid should be specified when merging tags, 
 
3530
            # so a tags implementation that versions tags can only 
 
3531
            # pull in the most recent changes. -- JRV20090506
 
3532
            result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
 
3533
                overwrite, ignore_master=not merge_tags_to_master)
 
3534
            result.new_revno, result.new_revid = self.target.last_revision_info()
 
3535
            if _hook_master:
 
3536
                result.master_branch = _hook_master
 
3537
                result.local_branch = result.target_branch
 
3538
            else:
 
3539
                result.master_branch = result.target_branch
 
3540
                result.local_branch = None
 
3541
            if run_hooks:
 
3542
                for hook in Branch.hooks['post_pull']:
 
3543
                    hook(result)
3436
3544
        finally:
3437
 
            if master_branch:
3438
 
                master_branch.unlock()
 
3545
            self.source.unlock()
 
3546
        return result
3439
3547
 
3440
3548
 
3441
3549
InterBranch.register_optimiser(GenericInterBranch)
3442
 
InterBranch.register_optimiser(InterToBranch5)