/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: Jelmer Vernooij
  • Date: 2020-07-05 12:50:01 UTC
  • mfrom: (7490.40.46 work)
  • mto: (7490.40.48 work)
  • mto: This revision was merged to the branch mainline in revision 7519.
  • Revision ID: jelmer@jelmer.uk-20200705125001-7s3vo0p55szbbws7
Merge lp:brz/3.1.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/git/interrepo.py
16
16
 
17
17
"""InterRepository operations."""
18
18
 
 
19
from __future__ import absolute_import
 
20
 
19
21
from io import BytesIO
20
22
import itertools
21
23
 
50
52
from ..revision import (
51
53
    NULL_REVISION,
52
54
    )
 
55
from ..sixish import (
 
56
    viewitems,
 
57
    viewvalues,
 
58
    )
53
59
from .. import (
54
60
    config,
55
61
    trace,
224
230
                        new_stop_revids.append(revid)
225
231
                stop_revids = set()
226
232
                parent_map = graph.get_parent_map(new_stop_revids)
227
 
                for parent_revids in parent_map.values():
 
233
                for parent_revids in viewvalues(parent_map):
228
234
                    stop_revids.update(parent_revids)
229
235
                pb.update("determining revisions to fetch", len(missing))
230
236
        return graph.iter_topo_order(missing)
243
249
                # broken symref?
244
250
                continue
245
251
            revid = None
246
 
            if v and not v.startswith(SYMREF):
 
252
            if not v.startswith(SYMREF):
247
253
                try:
248
254
                    for (kind, type_data) in self.source_store.lookup_git_sha(
249
255
                            v):
267
273
                 for (git_sha, bzr_revid) in new_refs.values()
268
274
                 if git_sha is None or not git_sha.startswith(SYMREF)],
269
275
                lossy=lossy)
270
 
            for name, (gitid, revid) in new_refs.items():
 
276
            for name, (gitid, revid) in viewitems(new_refs):
271
277
                if gitid is None:
272
278
                    try:
273
279
                        gitid = revidmap[revid][0]
309
315
                        try:
310
316
                            self.mapping.revision_id_bzr_to_foreign(old_revid)
311
317
                        except InvalidRevisionId:
312
 
                            pass
 
318
                            refname = self.mapping.revid_as_refname(old_revid)
 
319
                            self.target_refs[refname] = git_sha
313
320
                    revidmap[old_revid] = (git_sha, new_revid)
314
321
                self.target_store.add_objects(object_generator)
315
322
                return revidmap
356
363
        def git_update_refs(old_refs):
357
364
            ret = {}
358
365
            self.old_refs = {
359
 
                k: (v, None) for (k, v) in old_refs.items()}
 
366
                k: (v, None) for (k, v) in viewitems(old_refs)}
360
367
            new_refs = update_refs(self.old_refs)
361
 
            for name, (gitid, revid) in new_refs.items():
 
368
            for name, (gitid, revid) in viewitems(new_refs):
362
369
                if gitid is None:
363
370
                    git_sha = self.source_store._lookup_revision_sha1(revid)
364
371
                    gitid = unpeel_map.re_unpeel_tag(
417
424
 
418
425
        def determine_wants(refs):
419
426
            unpeel_lookup = {}
420
 
            for k, v in refs.items():
 
427
            for k, v in viewitems(refs):
421
428
                if k.endswith(ANNOTATED_TAG_SUFFIX):
422
429
                    unpeel_lookup[v] = refs[k[:-len(ANNOTATED_TAG_SUFFIX)]]
423
430
            potential = set([unpeel_lookup.get(w, w) for w in wants])
424
431
            if include_tags:
425
 
                for k, sha in refs.items():
 
432
                for k, sha in viewitems(refs):
426
433
                    if k.endswith(ANNOTATED_TAG_SUFFIX):
427
434
                        continue
428
435
                    try:
465
472
            if if_present_ids is not None:
466
473
                todo.update(if_present_ids)
467
474
        result_set = todo.difference(self.target.all_revision_ids())
468
 
        result_parents = set(itertools.chain.from_iterable(
469
 
            self.source.get_graph().get_parent_map(result_set).values()))
 
475
        result_parents = set(itertools.chain.from_iterable(viewvalues(
 
476
            self.source.get_graph().get_parent_map(result_set))))
470
477
        included_keys = result_set.intersection(result_parents)
471
478
        start_keys = result_set.difference(included_keys)
472
479
        exclude_keys = result_parents.difference(result_set)
491
498
 
492
499
    def determine_wants_all(self, refs):
493
500
        potential = set()
494
 
        for k, v in refs.items():
 
501
        for k, v in viewitems(refs):
495
502
            # For non-git target repositories, only worry about peeled
496
503
            if v == ZERO_SHA:
497
504
                continue
565
572
        all_revs = self.target.all_revision_ids()
566
573
        parent_map = self.target.get_parent_map(all_revs)
567
574
        all_parents = set()
568
 
        for values in parent_map.values():
 
575
        for values in viewvalues(parent_map):
569
576
            all_parents.update(values)
570
577
        return set(all_revs) - all_parents
571
578
 
649
656
 
650
657
        def determine_wants(heads):
651
658
            old_refs = dict([(k, (v, None))
652
 
                             for (k, v) in heads.as_dict().items()])
 
659
                             for (k, v) in viewitems(heads.as_dict())])
653
660
            new_refs = update_refs(old_refs)
654
661
            ref_changes.update(new_refs)
655
 
            return [sha1 for (sha1, bzr_revid) in new_refs.values()]
 
662
            return [sha1 for (sha1, bzr_revid) in viewvalues(new_refs)]
656
663
        self.fetch_objects(determine_wants, lossy=lossy)
657
 
        for k, (git_sha, bzr_revid) in ref_changes.items():
 
664
        for k, (git_sha, bzr_revid) in viewitems(ref_changes):
658
665
            self.target._git.refs[k] = git_sha
659
666
        new_refs = self.target.controldir.get_refs_container()
660
667
        return None, old_refs, new_refs
708
715
    def get_determine_wants_branches(self, branches, include_tags=False):
709
716
        def determine_wants(refs):
710
717
            ret = []
711
 
            for name, value in refs.items():
 
718
            for name, value in viewitems(refs):
712
719
                if value == ZERO_SHA:
713
720
                    continue
714
721
 
788
795
        """Be compatible with GitRepository."""
789
796
        return (isinstance(source, RemoteGitRepository) and
790
797
                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))