/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/interrepo.py

  • Committer: Breezy landing bot
  • Author(s): Gustav Hartvigsson
  • Date: 2021-01-10 18:46:30 UTC
  • mfrom: (7526.1.1 brz-removed-api-doc)
  • mto: This revision was merged to the branch mainline in revision 7532.
  • Revision ID: breezy.the.bot@gmail.com-20210110184630-dxu0g9dqq020uiw6
Drop documentation for removed API API.

Merged from https://code.launchpad.net/~gustav-hartvigsson/brz/removed-api-doc/+merge/396033

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/git/interrepo.py
75
75
    )
76
76
from .refs import (
77
77
    is_tag,
 
78
    ref_to_tag_name,
78
79
    )
79
80
from .repository import (
80
81
    GitRepository,
83
84
    )
84
85
from .remote import (
85
86
    RemoteGitRepository,
 
87
    RemoteGitError,
86
88
    )
87
89
from .unpeel_map import (
88
90
    UnpeelMap,
241
243
                # broken symref?
242
244
                continue
243
245
            revid = None
244
 
            if not v.startswith(SYMREF):
 
246
            if v and not v.startswith(SYMREF):
245
247
                try:
246
248
                    for (kind, type_data) in self.source_store.lookup_git_sha(
247
249
                            v):
260
262
        with self.source_store.lock_read():
261
263
            old_refs = self._get_target_bzr_refs()
262
264
            new_refs = update_refs(old_refs)
263
 
            revidmap = self.fetch_objects(
 
265
            revidmap = self.fetch_revs(
264
266
                [(git_sha, bzr_revid)
265
267
                 for (git_sha, bzr_revid) in new_refs.values()
266
268
                 if git_sha is None or not git_sha.startswith(SYMREF)],
284
286
                    result_refs[name] = (gitid, revid if not lossy else self.mapping.revision_id_foreign_to_bzr(gitid))
285
287
        return revidmap, old_refs, result_refs
286
288
 
287
 
    def fetch_objects(self, revs, lossy, limit=None):
 
289
    def fetch_revs(self, revs, lossy, limit=None):
288
290
        if not lossy and not self.mapping.roundtripping:
289
291
            for git_sha, bzr_revid in revs:
290
292
                if (bzr_revid is not None and
307
309
                        try:
308
310
                            self.mapping.revision_id_bzr_to_foreign(old_revid)
309
311
                        except InvalidRevisionId:
310
 
                            refname = self.mapping.revid_as_refname(old_revid)
311
 
                            self.target_refs[refname] = git_sha
 
312
                            pass
312
313
                    revidmap[old_revid] = (git_sha, new_revid)
313
314
                self.target_store.add_objects(object_generator)
314
315
                return revidmap
331
332
                              for revid in self.source.all_revision_ids()]
332
333
        self._warn_slow()
333
334
        try:
334
 
            revidmap = self.fetch_objects(stop_revisions, lossy=lossy)
 
335
            revidmap = self.fetch_revs(stop_revisions, lossy=lossy)
335
336
        except NoPushSupport:
336
337
            raise NoRoundtrippingSupport(self.source, self.target)
337
338
        return FetchResult(revidmap)
370
371
            return ret
371
372
        self._warn_slow()
372
373
        with self.source_store.lock_read():
373
 
            new_refs = self.target.send_pack(
 
374
            result = self.target.send_pack(
374
375
                git_update_refs, self.source_store.generate_lossy_pack_data)
 
376
            if result is not None and not isinstance(result, dict):
 
377
                for ref, error in result.ref_status.items():
 
378
                    if error:
 
379
                        raise RemoteGitError(
 
380
                            'unable to update ref %r: %s' % (ref, error))
 
381
                new_refs = result.refs
 
382
            else:  # dulwich < 0.20.3
 
383
                new_refs = result
375
384
        # FIXME: revidmap?
376
385
        return revidmap, self.old_refs, new_refs
377
386
 
403
412
    def _target_has_shas(self, shas):
404
413
        raise NotImplementedError(self._target_has_shas)
405
414
 
406
 
    def get_determine_wants_heads(self, wants, include_tags=False):
 
415
    def get_determine_wants_heads(self, wants, include_tags=False, tag_selector=None):
407
416
        wants = set(wants)
408
417
 
409
418
        def determine_wants(refs):
416
425
                for k, sha in refs.items():
417
426
                    if k.endswith(ANNOTATED_TAG_SUFFIX):
418
427
                        continue
419
 
                    if not is_tag(k):
 
428
                    try:
 
429
                        tag_name = ref_to_tag_name(k)
 
430
                    except ValueError:
 
431
                        continue
 
432
                    if tag_selector and not tag_selector(tag_name):
420
433
                        continue
421
434
                    if sha == ZERO_SHA:
422
435
                        continue
502
515
        """
503
516
        raise NotImplementedError(self.fetch_objects)
504
517
 
505
 
    def get_determine_wants_revids(self, revids, include_tags=False):
 
518
    def get_determine_wants_revids(self, revids, include_tags=False, tag_selector=None):
506
519
        wants = set()
507
520
        for revid in set(revids):
508
521
            if self.target.has_revision(revid):
509
522
                continue
510
523
            git_sha, mapping = self.source.lookup_bzr_revision_id(revid)
511
524
            wants.add(git_sha)
512
 
        return self.get_determine_wants_heads(wants, include_tags=include_tags)
 
525
        return self.get_determine_wants_heads(
 
526
            wants, include_tags=include_tags, tag_selector=tag_selector)
513
527
 
514
528
    def fetch(self, revision_id=None, find_ghosts=False,
515
529
              mapping=None, fetch_spec=None, include_tags=False, lossy=False):
682
696
        result.refs = wants_recorder.remote_refs
683
697
        return result
684
698
 
685
 
    def get_determine_wants_revids(self, revids, include_tags=False):
 
699
    def get_determine_wants_revids(self, revids, include_tags=False, tag_selector=None):
686
700
        wants = set()
687
701
        for revid in set(revids):
688
702
            if revid == NULL_REVISION:
689
703
                continue
690
704
            git_sha, mapping = self.source.lookup_bzr_revision_id(revid)
691
705
            wants.add(git_sha)
692
 
        return self.get_determine_wants_heads(wants, include_tags=include_tags)
 
706
        return self.get_determine_wants_heads(wants, include_tags=include_tags, tag_selector=tag_selector)
693
707
 
694
708
    def get_determine_wants_branches(self, branches, include_tags=False):
695
709
        def determine_wants(refs):
774
788
        """Be compatible with GitRepository."""
775
789
        return (isinstance(source, RemoteGitRepository) and
776
790
                isinstance(target, LocalGitRepository))
 
791
 
 
792
 
 
793
 
 
794
class InterLocalGitRemoteGitRepository(InterToGitRepository):
 
795
 
 
796
    def fetch_refs(self, update_refs, lossy=False, overwrite=False):
 
797
        """Import the gist of the ancestry of a particular revision."""
 
798
        if lossy:
 
799
            raise LossyPushToSameVCS(self.source, self.target)
 
800
 
 
801
        def git_update_refs(old_refs):
 
802
            ret = {}
 
803
            self.old_refs = {
 
804
                k: (v, None) for (k, v) in viewitems(old_refs)}
 
805
            new_refs = update_refs(self.old_refs)
 
806
            for name, (gitid, revid) in viewitems(new_refs):
 
807
                if gitid is None:
 
808
                    gitid = self.source_store._lookup_revision_sha1(revid)
 
809
                if not overwrite:
 
810
                    if remote_divergence(
 
811
                            old_refs.get(name), gitid, self.source_store):
 
812
                        raise DivergedBranches(self.source, self.target)
 
813
                ret[name] = gitid
 
814
            return ret
 
815
        new_refs = self.target.send_pack(
 
816
            git_update_refs,
 
817
            self.source._git.generate_pack_data)
 
818
        return None, self.old_refs, new_refs
 
819
 
 
820
    @staticmethod
 
821
    def is_compatible(source, target):
 
822
        return (isinstance(source, LocalGitRepository) and
 
823
                isinstance(target, RemoteGitRepository))