/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to breezy/git/branch.py

  • Committer: Jelmer Vernooij
  • Date: 2018-11-11 04:08:32 UTC
  • mto: (7143.16.20 even-more-cleanups)
  • mto: This revision was merged to the branch mainline in revision 7175.
  • Revision ID: jelmer@jelmer.uk-20181111040832-nsljjynzzwmznf3h
Run autopep8.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/git/branch.py
79
79
from .urls import git_url_to_bzr_url
80
80
 
81
81
 
82
 
 
83
82
class GitPullResult(branch.PullResult):
84
83
    """Result of a pull from a Git branch."""
85
84
 
109
108
    def _merge_to_remote_git(self, target_repo, source_tag_refs, overwrite=False):
110
109
        updates = {}
111
110
        conflicts = []
 
111
 
112
112
        def get_changed_refs(old_refs):
113
113
            ret = dict(old_refs)
114
114
            for ref_name, tag_name, peeled, unpeeled in source_tag_refs.iteritems():
116
116
                    pass
117
117
                elif overwrite or not ref_name in old_refs:
118
118
                    ret[ref_name] = unpeeled
119
 
                    updates[tag_name] = target_repo.lookup_foreign_revision_id(peeled)
 
119
                    updates[tag_name] = target_repo.lookup_foreign_revision_id(
 
120
                        peeled)
120
121
                else:
121
122
                    conflicts.append(
122
123
                        (tag_name,
123
 
                        self.repository.lookup_foreign_revision_id(peeled),
124
 
                        target_repo.lookup_foreign_revision_id(old_refs[ref_name])))
 
124
                         self.repository.lookup_foreign_revision_id(peeled),
 
125
                         target_repo.lookup_foreign_revision_id(old_refs[ref_name])))
125
126
            return ret
126
 
        target_repo.controldir.send_pack(get_changed_refs, lambda have, want: [])
 
127
        target_repo.controldir.send_pack(
 
128
            get_changed_refs, lambda have, want: [])
127
129
        return updates, conflicts
128
130
 
129
131
    def _merge_to_local_git(self, target_repo, source_tag_refs, overwrite=False):
134
136
                pass
135
137
            elif overwrite or not ref_name in target_repo._git.refs:
136
138
                target_repo._git.refs[ref_name] = unpeeled or peeled
137
 
                updates[tag_name] = self.repository.lookup_foreign_revision_id(peeled)
 
139
                updates[tag_name] = self.repository.lookup_foreign_revision_id(
 
140
                    peeled)
138
141
            else:
139
 
                source_revid = self.repository.lookup_foreign_revision_id(peeled)
 
142
                source_revid = self.repository.lookup_foreign_revision_id(
 
143
                    peeled)
140
144
                try:
141
145
                    target_revid = target_repo.lookup_foreign_revision_id(
142
 
                            target_repo._git.refs[ref_name])
 
146
                        target_repo._git.refs[ref_name])
143
147
                except KeyError:
144
148
                    trace.warning('%s does not point to a valid object',
145
149
                                  ref_name)
204
208
                master.lock_write()
205
209
            try:
206
210
                updates, conflicts = self._merge_to_non_git(to_tags, source_tag_refs,
207
 
                                                  overwrite=overwrite)
 
211
                                                            overwrite=overwrite)
208
212
                if master is not None:
209
213
                    extra_updates, extra_conflicts = self.merge_to(
210
214
                        master.tags, overwrite=overwrite,
211
 
                                               source_tag_refs=source_tag_refs,
212
 
                                               ignore_master=ignore_master)
 
215
                        source_tag_refs=source_tag_refs,
 
216
                        ignore_master=ignore_master)
213
217
                    updates.update(extra_updates)
214
218
                    conflicts += extra_conflicts
215
219
                return updates, conflicts
322
326
        if not isinstance(a_controldir, LocalGitDir):
323
327
            raise errors.IncompatibleFormat(self, a_controldir._format)
324
328
        return a_controldir.create_branch(repository=repository, name=name,
325
 
            append_revisions_only=append_revisions_only)
 
329
                                          append_revisions_only=append_revisions_only)
326
330
 
327
331
 
328
332
class GitBranch(ForeignBranch):
399
403
 
400
404
    def _set_nick(self, nick):
401
405
        cf = self.repository._git.get_config()
402
 
        cf.set((b"branch", self.name.encode('utf-8')), b"nick", nick.encode("utf-8"))
 
406
        cf.set((b"branch", self.name.encode('utf-8')),
 
407
               b"nick", nick.encode("utf-8"))
403
408
        f = BytesIO()
404
409
        cf.write_to_file(f)
405
410
        self.repository._git._put_named_file('config', f.getvalue())
408
413
 
409
414
    def __repr__(self):
410
415
        return "<%s(%r, %r)>" % (self.__class__.__name__, self.repository.base,
411
 
            self.name)
 
416
                                 self.name)
412
417
 
413
418
    def generate_revision_history(self, revid, last_rev=None, other_branch=None):
414
419
        if last_rev is not None:
544
549
    def lookup_foreign_revision_id(self, foreign_revid):
545
550
        try:
546
551
            return self.repository.lookup_foreign_revision_id(foreign_revid,
547
 
                self.mapping)
 
552
                                                              self.mapping)
548
553
        except KeyError:
549
554
            # Let's try..
550
555
            return self.mapping.revision_id_foreign_to_bzr(foreign_revid)
580
585
 
581
586
    def __init__(self, controldir, repository, ref):
582
587
        super(LocalGitBranch, self).__init__(controldir, repository, ref,
583
 
                LocalGitBranchFormat())
 
588
                                             LocalGitBranchFormat())
584
589
 
585
590
    def create_checkout(self, to_location, revision_id=None, lightweight=False,
586
 
        accelerator_tree=None, hardlink=False):
 
591
                        accelerator_tree=None, hardlink=False):
587
592
        t = transport.get_transport(to_location)
588
593
        t.ensure_base()
589
594
        format = self._get_checkout_format(lightweight=lightweight)
599
604
            checkout_branch.pull(self, stop_revision=revision_id)
600
605
            from_branch = None
601
606
        return checkout.create_workingtree(revision_id,
602
 
                from_branch=from_branch, hardlink=hardlink)
 
607
                                           from_branch=from_branch, hardlink=hardlink)
603
608
 
604
609
    def _lock_ref(self):
605
610
        self._ref_lock = self.repository._git.refs.lock_ref(self.ref)
621
626
        graph = self.repository.get_graph()
622
627
        try:
623
628
            ret = list(graph.iter_lefthand_ancestry(last_revid,
624
 
                (revision.NULL_REVISION, )))
 
629
                                                    (revision.NULL_REVISION, )))
625
630
        except errors.RevisionNotPresent as e:
626
631
            raise errors.GhostRevisionsHaveNoRevno(last_revid, e.revision_id)
627
632
        ret.reverse()
637
642
        last_revid = self.last_revision()
638
643
        graph = self.repository.get_graph()
639
644
        revno = graph.find_distance_to_null(last_revid,
640
 
            [(revision.NULL_REVISION, 0)])
 
645
                                            [(revision.NULL_REVISION, 0)])
641
646
        return revno, last_revid
642
647
 
643
648
    def set_last_revision_info(self, revno, revision_id):
716
721
        # FIXME should provide multiple branches, based on config
717
722
        url = urlutils.join(self.user_url, path)
718
723
        return branch.Branch.open(
719
 
                url,
720
 
                possible_transports=possible_transports)
721
 
 
 
724
            url,
 
725
            possible_transports=possible_transports)
722
726
 
723
727
 
724
728
def _quick_lookup_revno(local_branch, remote_branch, revid):
732
736
            graph = local_branch.repository.get_graph()
733
737
            try:
734
738
                return graph.find_distance_to_null(revid,
735
 
                    [(revision.NULL_REVISION, 0)])
 
739
                                                   [(revision.NULL_REVISION, 0)])
736
740
            except errors.GhostRevisionsHaveNoRevno:
737
741
                # FIXME: Check using graph.find_distance_to_null() ?
738
742
                with remote_branch.lock_read():
753
757
                to_file.write('No revisions to pull.\n')
754
758
            elif self.new_git_head is not None:
755
759
                to_file.write('Now on revision %d (git sha: %s).\n' %
756
 
                        (self.new_revno, self.new_git_head))
 
760
                              (self.new_revno, self.new_git_head))
757
761
            else:
758
762
                to_file.write('Now on revision %d.\n' % (self.new_revno,))
759
763
        self._show_tag_conficts(to_file)
760
764
 
761
765
    def _lookup_revno(self, revid):
762
766
        return _quick_lookup_revno(self.target_branch, self.source_branch,
763
 
            revid)
 
767
                                   revid)
764
768
 
765
769
    def _get_old_revno(self):
766
770
        if self._old_revno is not None:
787
791
 
788
792
    def _lookup_revno(self, revid):
789
793
        return _quick_lookup_revno(self.source_branch, self.target_branch,
790
 
            revid)
 
794
                                   revid)
791
795
 
792
796
    @property
793
797
    def old_revno(self):
841
845
        if fetch_tags is None:
842
846
            c = self.source.get_config_stack()
843
847
            fetch_tags = c.get('branch.fetch_tags')
 
848
 
844
849
        def determine_wants(heads):
845
850
            if stop_revision is None:
846
851
                try:
848
853
                except KeyError:
849
854
                    self._last_revid = revision.NULL_REVISION
850
855
                else:
851
 
                    self._last_revid = self.source.lookup_foreign_revision_id(head)
 
856
                    self._last_revid = self.source.lookup_foreign_revision_id(
 
857
                        head)
852
858
            else:
853
859
                self._last_revid = stop_revision
854
860
            real = interrepo.get_determine_wants_revids(
857
863
        pack_hint, head, refs = interrepo.fetch_objects(
858
864
            determine_wants, self.source.mapping, limit=limit)
859
865
        if (pack_hint is not None and
860
 
            self.target.repository._format.pack_compresses):
 
866
                self.target.repository._format.pack_compresses):
861
867
            self.target.repository.pack(hint=pack_hint)
862
868
        return head, refs
863
869
 
868
874
        else:
869
875
            prev_last_revid = self.target.last_revision()
870
876
        self.target.generate_revision_history(self._last_revid,
871
 
            last_rev=prev_last_revid, other_branch=self.source)
 
877
                                              last_rev=prev_last_revid, other_branch=self.source)
872
878
        return head, refs
873
879
 
874
880
    def _basic_pull(self, stop_revision, overwrite, run_hooks,
875
 
              _override_hook_target, _hook_master):
 
881
                    _override_hook_target, _hook_master):
876
882
        if overwrite is True:
877
883
            overwrite = set(["history", "tags"])
878
884
        else:
890
896
                self.target.last_revision_info()
891
897
            result.new_git_head, remote_refs = self._update_revisions(
892
898
                stop_revision, overwrite=("history" in overwrite))
893
 
            tags_ret  = self.source.tags.merge_to(
894
 
                    self.target.tags, ("tags" in overwrite), ignore_master=True)
 
899
            tags_ret = self.source.tags.merge_to(
 
900
                self.target.tags, ("tags" in overwrite), ignore_master=True)
895
901
            if isinstance(tags_ret, tuple):
896
902
                result.tag_updates, result.tag_conflicts = tags_ret
897
903
            else:
947
953
                if master_branch:
948
954
                    # pull from source into master.
949
955
                    master_branch.pull(self.source, overwrite, stop_revision,
950
 
                        run_hooks=False)
 
956
                                       run_hooks=False)
951
957
                result = self._basic_pull(stop_revision, overwrite, run_hooks,
952
 
                    _override_hook_target, _hook_master=master_branch)
 
958
                                          _override_hook_target, _hook_master=master_branch)
953
959
            finally:
954
960
                self.source.unlock()
955
961
        finally:
969
975
        result.new_git_head, remote_refs = self._update_revisions(
970
976
            stop_revision, overwrite=("history" in overwrite))
971
977
        tags_ret = self.source.tags.merge_to(self.target.tags,
972
 
            "tags" in overwrite, ignore_master=True)
 
978
                                             "tags" in overwrite, ignore_master=True)
973
979
        (result.tag_updates, result.tag_conflicts) = tags_ret
974
980
        result.new_revno, result.new_revid = self.target.last_revision_info()
975
981
        return result
1003
1009
        result.target_branch = self.target
1004
1010
        if stop_revision is None:
1005
1011
            stop_revision = self.source.last_revision()
 
1012
 
1006
1013
        def get_changed_refs(old_refs):
1007
1014
            old_ref = old_refs.get(self.target.ref, None)
1008
1015
            if old_ref is None:
1009
1016
                result.old_revid = revision.NULL_REVISION
1010
1017
            else:
1011
 
                result.old_revid = self.target.lookup_foreign_revision_id(old_ref)
1012
 
            new_ref = self.source.repository.lookup_bzr_revision_id(stop_revision)[0]
 
1018
                result.old_revid = self.target.lookup_foreign_revision_id(
 
1019
                    old_ref)
 
1020
            new_ref = self.source.repository.lookup_bzr_revision_id(stop_revision)[
 
1021
                0]
1013
1022
            if not overwrite:
1014
1023
                if remote_divergence(old_ref, new_ref, self.source.repository._git.object_store):
1015
1024
                    raise errors.DivergedBranches(self.source, self.target)
1016
 
            refs = { self.target.ref: new_ref }
 
1025
            refs = {self.target.ref: new_ref}
1017
1026
            result.new_revid = stop_revision
1018
1027
            for name, sha in viewitems(self.source.repository._git.refs.as_dict(b"refs/tags")):
1019
1028
                refs[tag_name_to_ref(name)] = sha
1020
1029
            return refs
1021
1030
        self.target.repository.send_pack(get_changed_refs,
1022
 
            self.source.repository._git.object_store.generate_pack_data)
 
1031
                                         self.source.repository._git.object_store.generate_pack_data)
1023
1032
        return result
1024
1033
 
1025
1034
 
1040
1049
 
1041
1050
    def fetch(self, stop_revision=None, fetch_tags=None, limit=None):
1042
1051
        interrepo = _mod_repository.InterRepository.get(self.source.repository,
1043
 
            self.target.repository)
 
1052
                                                        self.target.repository)
1044
1053
        if stop_revision is None:
1045
1054
            stop_revision = self.source.last_revision()
1046
1055
        determine_wants = interrepo.get_determine_wants_revids(
1058
1067
        result.old_revid = self.target.last_revision()
1059
1068
        refs, stop_revision = self.update_refs(stop_revision)
1060
1069
        self.target.generate_revision_history(stop_revision,
1061
 
                (result.old_revid if ("history" not in overwrite) else None),
1062
 
                other_branch=self.source)
 
1070
                                              (result.old_revid if (
 
1071
                                                  "history" not in overwrite) else None),
 
1072
                                              other_branch=self.source)
1063
1073
        tags_ret = self.source.tags.merge_to(self.target.tags,
1064
 
            source_tag_refs=remote_refs_dict_to_tag_refs(refs),
1065
 
            overwrite=("tags" in overwrite))
 
1074
                                             source_tag_refs=remote_refs_dict_to_tag_refs(
 
1075
                                                 refs),
 
1076
                                             overwrite=("tags" in overwrite))
1066
1077
        if isinstance(tags_ret, tuple):
1067
1078
            (result.tag_updates, result.tag_conflicts) = tags_ret
1068
1079
        else:
1072
1083
 
1073
1084
    def update_refs(self, stop_revision=None):
1074
1085
        interrepo = _mod_repository.InterRepository.get(
1075
 
                self.source.repository, self.target.repository)
 
1086
            self.source.repository, self.target.repository)
1076
1087
        c = self.source.get_config_stack()
1077
1088
        fetch_tags = c.get('branch.fetch_tags')
1078
1089
 
1085
1096
            else:
1086
1097
                stop_revision = self.target.lookup_foreign_revision_id(head)
1087
1098
        else:
1088
 
            refs = interrepo.fetch(revision_id=stop_revision, include_tags=fetch_tags)
 
1099
            refs = interrepo.fetch(
 
1100
                revision_id=stop_revision, include_tags=fetch_tags)
1089
1101
        return refs, stop_revision
1090
1102
 
1091
1103
    def pull(self, stop_revision=None, overwrite=False,
1105
1117
            result.old_revid = self.target.last_revision()
1106
1118
            refs, stop_revision = self.update_refs(stop_revision)
1107
1119
            self.target.generate_revision_history(stop_revision,
1108
 
                    (result.old_revid if ("history" not in overwrite) else None),
1109
 
                    other_branch=self.source)
 
1120
                                                  (result.old_revid if (
 
1121
                                                      "history" not in overwrite) else None),
 
1122
                                                  other_branch=self.source)
1110
1123
            tags_ret = self.source.tags.merge_to(self.target.tags,
1111
 
                overwrite=("tags" in overwrite),
1112
 
                source_tag_refs=remote_refs_dict_to_tag_refs(refs))
 
1124
                                                 overwrite=(
 
1125
                                                     "tags" in overwrite),
 
1126
                                                 source_tag_refs=remote_refs_dict_to_tag_refs(refs))
1113
1127
            if isinstance(tags_ret, tuple):
1114
1128
                (result.tag_updates, result.tag_conflicts) = tags_ret
1115
1129
            else:
1129
1143
    def __init__(self, source, target):
1130
1144
        super(InterToGitBranch, self).__init__(source, target)
1131
1145
        self.interrepo = _mod_repository.InterRepository.get(source.repository,
1132
 
                                           target.repository)
 
1146
                                                             target.repository)
1133
1147
 
1134
1148
    @staticmethod
1135
1149
    def _get_branch_formats_to_test():
1157
1171
        if not isinstance(stop_revision, bytes):
1158
1172
            raise TypeError(stop_revision)
1159
1173
        main_ref = self.target.ref
1160
 
        refs = { main_ref: (None, stop_revision) }
 
1174
        refs = {main_ref: (None, stop_revision)}
1161
1175
        if fetch_tags is None:
1162
1176
            c = self.source.get_config_stack()
1163
1177
            fetch_tags = c.get('branch.fetch_tags')
1166
1180
                ref = tag_name_to_ref(name)
1167
1181
                if not check_ref_format(ref):
1168
1182
                    warning("skipping tag with invalid characters %s (%s)",
1169
 
                        name, ref)
 
1183
                            name, ref)
1170
1184
                    continue
1171
1185
                if fetch_tags:
1172
1186
                    # FIXME: Skip tags that are not in the ancestry
1179
1193
        result.tag_updates = {}
1180
1194
        result.tag_conflicts = []
1181
1195
        ret = dict(old_refs)
 
1196
 
1182
1197
        def ref_equals(refs, ref, git_sha, revid):
1183
1198
            try:
1184
1199
                value = refs[ref]
1186
1201
                return False
1187
1202
            if (value[0] is not None and
1188
1203
                git_sha is not None and
1189
 
                value[0] == git_sha):
 
1204
                    value[0] == git_sha):
1190
1205
                return True
1191
1206
            if (value[1] is not None and
1192
1207
                revid is not None and
1193
 
                value[1] == revid):
 
1208
                    value[1] == revid):
1194
1209
                return True
1195
1210
            # FIXME: If one side only has the git sha available and the other only
1196
1211
            # has the bzr revid, then this will cause us to show a tag as updated
1222
1237
                    except ValueError:
1223
1238
                        pass
1224
1239
                    else:
1225
 
                        result.tag_conflicts.append((name, revid, ret[name][1]))
 
1240
                        result.tag_conflicts.append(
 
1241
                            (name, revid, ret[name][1]))
1226
1242
                else:
1227
1243
                    ret[ref] = (git_sha, revid)
1228
1244
        return ret
1248
1264
        with self.source.lock_read(), self.target.lock_write():
1249
1265
            new_refs, main_ref, stop_revinfo = self._get_new_refs(
1250
1266
                stop_revision)
 
1267
 
1251
1268
            def update_refs(old_refs):
1252
1269
                return self._update_refs(result, old_refs, new_refs, overwrite)
1253
1270
            try:
1255
1272
                    update_refs, lossy=False)
1256
1273
            except NoPushSupport:
1257
1274
                raise errors.NoRoundtrippingSupport(self.source, self.target)
1258
 
            (old_sha1, result.old_revid) = old_refs.get(main_ref, (ZERO_SHA, NULL_REVISION))
 
1275
            (old_sha1, result.old_revid) = old_refs.get(
 
1276
                main_ref, (ZERO_SHA, NULL_REVISION))
1259
1277
            if result.old_revid is None:
1260
 
                result.old_revid = self.target.lookup_foreign_revision_id(old_sha1)
 
1278
                result.old_revid = self.target.lookup_foreign_revision_id(
 
1279
                    old_sha1)
1261
1280
            result.new_revid = new_refs[main_ref][1]
1262
1281
            result.local_branch = None
1263
1282
            result.master_branch = self.target
1274
1293
        result.local_branch = None
1275
1294
        result.master_branch = result.target_branch
1276
1295
        with self.source.lock_read(), self.target.lock_write():
1277
 
            new_refs, main_ref, stop_revinfo = self._get_new_refs(stop_revision)
 
1296
            new_refs, main_ref, stop_revinfo = self._get_new_refs(
 
1297
                stop_revision)
 
1298
 
1278
1299
            def update_refs(old_refs):
1279
1300
                return self._update_refs(result, old_refs, new_refs, overwrite)
1280
1301
            try:
1282
1303
                    update_refs, lossy=lossy, overwrite=overwrite)
1283
1304
            except NoPushSupport:
1284
1305
                raise errors.NoRoundtrippingSupport(self.source, self.target)
1285
 
            (old_sha1, result.old_revid) = old_refs.get(main_ref, (ZERO_SHA, NULL_REVISION))
 
1306
            (old_sha1, result.old_revid) = old_refs.get(
 
1307
                main_ref, (ZERO_SHA, NULL_REVISION))
1286
1308
            if result.old_revid is None:
1287
 
                result.old_revid = self.target.lookup_foreign_revision_id(old_sha1)
 
1309
                result.old_revid = self.target.lookup_foreign_revision_id(
 
1310
                    old_sha1)
1288
1311
            result.new_revid = new_refs[main_ref][1]
1289
1312
            (result.new_original_revno, result.new_original_revid) = stop_revinfo
1290
1313
            for hook in branch.Branch.hooks['post_push']: