/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: 2019-03-05 07:32:38 UTC
  • mto: (7290.1.21 work)
  • mto: This revision was merged to the branch mainline in revision 7311.
  • Revision ID: jelmer@jelmer.uk-20190305073238-zlqn981opwnqsmzi
Add appveyor configuration.

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
 
44
46
    NoSuchRevision,
45
47
    )
46
48
from ..repository import (
47
 
    FetchResult,
48
49
    InterRepository,
49
50
    )
50
51
from ..revision import (
51
52
    NULL_REVISION,
52
53
    )
 
54
from ..sixish import (
 
55
    viewitems,
 
56
    viewvalues,
 
57
    )
53
58
from .. import (
54
59
    config,
55
60
    trace,
75
80
    )
76
81
from .refs import (
77
82
    is_tag,
78
 
    ref_to_tag_name,
79
83
    )
80
84
from .repository import (
81
85
    GitRepository,
84
88
    )
85
89
from .remote import (
86
90
    RemoteGitRepository,
87
 
    RemoteGitError,
88
91
    )
89
92
from .unpeel_map import (
90
93
    UnpeelMap,
213
216
                stop_revids.append(revid)
214
217
        missing = set()
215
218
        graph = self.source.get_graph()
216
 
        with ui.ui_factory.nested_progress_bar() as pb:
 
219
        pb = ui.ui_factory.nested_progress_bar()
 
220
        try:
217
221
            while stop_revids:
218
222
                new_stop_revids = []
219
223
                for revid in stop_revids:
224
228
                        new_stop_revids.append(revid)
225
229
                stop_revids = set()
226
230
                parent_map = graph.get_parent_map(new_stop_revids)
227
 
                for parent_revids in parent_map.values():
 
231
                for parent_revids in viewvalues(parent_map):
228
232
                    stop_revids.update(parent_revids)
229
233
                pb.update("determining revisions to fetch", len(missing))
 
234
        finally:
 
235
            pb.finished()
230
236
        return graph.iter_topo_order(missing)
231
237
 
232
238
    def _get_target_bzr_refs(self):
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]
296
302
        with self.source_store.lock_read():
297
303
            todo = list(self.missing_revisions(revs))[:limit]
298
304
            revidmap = {}
299
 
            with ui.ui_factory.nested_progress_bar() as pb:
 
305
            pb = ui.ui_factory.nested_progress_bar()
 
306
            try:
300
307
                object_generator = MissingObjectsIterator(
301
308
                    self.source_store, self.source, pb)
302
309
                for (old_revid, git_sha) in object_generator.import_revisions(
309
316
                        try:
310
317
                            self.mapping.revision_id_bzr_to_foreign(old_revid)
311
318
                        except InvalidRevisionId:
312
 
                            pass
 
319
                            refname = self.mapping.revid_as_refname(old_revid)
 
320
                            self.target_refs[refname] = git_sha
313
321
                    revidmap[old_revid] = (git_sha, new_revid)
314
322
                self.target_store.add_objects(object_generator)
315
323
                return revidmap
 
324
            finally:
 
325
                pb.finished()
316
326
 
317
327
    def fetch(self, revision_id=None, pb=None, find_ghosts=False,
318
 
              fetch_spec=None, mapped_refs=None, lossy=False):
 
328
              fetch_spec=None, mapped_refs=None):
319
329
        if mapped_refs is not None:
320
330
            stop_revisions = mapped_refs
321
331
        elif revision_id is not None:
332
342
                              for revid in self.source.all_revision_ids()]
333
343
        self._warn_slow()
334
344
        try:
335
 
            revidmap = self.fetch_objects(stop_revisions, lossy=lossy)
 
345
            self.fetch_objects(stop_revisions, lossy=False)
336
346
        except NoPushSupport:
337
347
            raise NoRoundtrippingSupport(self.source, self.target)
338
 
        return FetchResult(revidmap)
339
348
 
340
349
    @staticmethod
341
350
    def is_compatible(source, target):
356
365
        def git_update_refs(old_refs):
357
366
            ret = {}
358
367
            self.old_refs = {
359
 
                k: (v, None) for (k, v) in old_refs.items()}
 
368
                k: (v, None) for (k, v) in viewitems(old_refs)}
360
369
            new_refs = update_refs(self.old_refs)
361
 
            for name, (gitid, revid) in new_refs.items():
 
370
            for name, (gitid, revid) in viewitems(new_refs):
362
371
                if gitid is None:
363
372
                    git_sha = self.source_store._lookup_revision_sha1(revid)
364
373
                    gitid = unpeel_map.re_unpeel_tag(
371
380
            return ret
372
381
        self._warn_slow()
373
382
        with self.source_store.lock_read():
374
 
            result = self.target.send_pack(
 
383
            new_refs = self.target.send_pack(
375
384
                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
384
385
        # FIXME: revidmap?
385
386
        return revidmap, self.old_refs, new_refs
386
387
 
412
413
    def _target_has_shas(self, shas):
413
414
        raise NotImplementedError(self._target_has_shas)
414
415
 
415
 
    def get_determine_wants_heads(self, wants, include_tags=False, tag_selector=None):
 
416
    def get_determine_wants_heads(self, wants, include_tags=False):
416
417
        wants = set(wants)
417
418
 
418
419
        def determine_wants(refs):
419
420
            unpeel_lookup = {}
420
 
            for k, v in refs.items():
 
421
            for k, v in viewitems(refs):
421
422
                if k.endswith(ANNOTATED_TAG_SUFFIX):
422
423
                    unpeel_lookup[v] = refs[k[:-len(ANNOTATED_TAG_SUFFIX)]]
423
424
            potential = set([unpeel_lookup.get(w, w) for w in wants])
424
425
            if include_tags:
425
 
                for k, sha in refs.items():
 
426
                for k, sha in viewitems(refs):
426
427
                    if k.endswith(ANNOTATED_TAG_SUFFIX):
427
428
                        continue
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):
 
429
                    if not is_tag(k):
433
430
                        continue
434
431
                    if sha == ZERO_SHA:
435
432
                        continue
465
462
            if if_present_ids is not None:
466
463
                todo.update(if_present_ids)
467
464
        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()))
 
465
        result_parents = set(itertools.chain.from_iterable(viewvalues(
 
466
            self.source.get_graph().get_parent_map(result_set))))
470
467
        included_keys = result_set.intersection(result_parents)
471
468
        start_keys = result_set.difference(included_keys)
472
469
        exclude_keys = result_parents.difference(result_set)
491
488
 
492
489
    def determine_wants_all(self, refs):
493
490
        potential = set()
494
 
        for k, v in refs.items():
 
491
        for k, v in viewitems(refs):
495
492
            # For non-git target repositories, only worry about peeled
496
493
            if v == ZERO_SHA:
497
494
                continue
515
512
        """
516
513
        raise NotImplementedError(self.fetch_objects)
517
514
 
518
 
    def get_determine_wants_revids(self, revids, include_tags=False, tag_selector=None):
 
515
    def get_determine_wants_revids(self, revids, include_tags=False):
519
516
        wants = set()
520
517
        for revid in set(revids):
521
518
            if self.target.has_revision(revid):
522
519
                continue
523
520
            git_sha, mapping = self.source.lookup_bzr_revision_id(revid)
524
521
            wants.add(git_sha)
525
 
        return self.get_determine_wants_heads(
526
 
            wants, include_tags=include_tags, tag_selector=tag_selector)
 
522
        return self.get_determine_wants_heads(wants, include_tags=include_tags)
527
523
 
528
524
    def fetch(self, revision_id=None, find_ghosts=False,
529
 
              mapping=None, fetch_spec=None, include_tags=False, lossy=False):
 
525
              mapping=None, fetch_spec=None, include_tags=False):
530
526
        if mapping is None:
531
527
            mapping = self.source.get_mapping()
532
528
        if revision_id is not None:
547
543
        else:
548
544
            determine_wants = self.determine_wants_all
549
545
 
550
 
        (pack_hint, _, remote_refs) = self.fetch_objects(
551
 
            determine_wants, mapping, lossy=lossy)
 
546
        (pack_hint, _, remote_refs) = self.fetch_objects(determine_wants,
 
547
                                                         mapping)
552
548
        if pack_hint is not None and self.target._format.pack_compresses:
553
549
            self.target.pack(hint=pack_hint)
554
 
        result = FetchResult()
555
 
        result.refs = remote_refs
556
 
        return result
 
550
        return remote_refs
557
551
 
558
552
 
559
553
class InterRemoteGitNonGitRepository(InterGitNonGitRepository):
565
559
        all_revs = self.target.all_revision_ids()
566
560
        parent_map = self.target.get_parent_map(all_revs)
567
561
        all_parents = set()
568
 
        for values in parent_map.values():
 
562
        for values in viewvalues(parent_map):
569
563
            all_parents.update(values)
570
564
        return set(all_revs) - all_parents
571
565
 
580
574
                lambda sha: store[sha].parents)
581
575
            wants_recorder = DetermineWantsRecorder(determine_wants)
582
576
 
583
 
            with ui.ui_factory.nested_progress_bar() as pb:
 
577
            pb = ui.ui_factory.nested_progress_bar()
 
578
            try:
584
579
                objects_iter = self.source.fetch_objects(
585
580
                    wants_recorder, graph_walker, store.get_raw)
586
581
                trace.mutter("Importing %d new revisions",
589
584
                    self.target, mapping, objects_iter, store,
590
585
                    wants_recorder.wants, pb, limit)
591
586
                return (pack_hint, last_rev, wants_recorder.remote_refs)
 
587
            finally:
 
588
                pb.finished()
592
589
 
593
590
    @staticmethod
594
591
    def is_compatible(source, target):
613
610
        self._warn_slow()
614
611
        remote_refs = self.source.controldir.get_refs_container().as_dict()
615
612
        wants = determine_wants(remote_refs)
 
613
        pb = ui.ui_factory.nested_progress_bar()
616
614
        target_git_object_retriever = get_object_store(self.target, mapping)
617
 
        with ui.ui_factory.nested_progress_bar() as pb:
 
615
        try:
618
616
            target_git_object_retriever.lock_write()
619
617
            try:
620
618
                (pack_hint, last_rev) = import_git_objects(
623
621
                return (pack_hint, last_rev, remote_refs)
624
622
            finally:
625
623
                target_git_object_retriever.unlock()
 
624
        finally:
 
625
            pb.finished()
626
626
 
627
627
    @staticmethod
628
628
    def is_compatible(source, target):
649
649
 
650
650
        def determine_wants(heads):
651
651
            old_refs = dict([(k, (v, None))
652
 
                             for (k, v) in heads.as_dict().items()])
 
652
                             for (k, v) in viewitems(heads.as_dict())])
653
653
            new_refs = update_refs(old_refs)
654
654
            ref_changes.update(new_refs)
655
 
            return [sha1 for (sha1, bzr_revid) in new_refs.values()]
 
655
            return [sha1 for (sha1, bzr_revid) in viewvalues(new_refs)]
656
656
        self.fetch_objects(determine_wants, lossy=lossy)
657
 
        for k, (git_sha, bzr_revid) in ref_changes.items():
 
657
        for k, (git_sha, bzr_revid) in viewitems(ref_changes):
658
658
            self.target._git.refs[k] = git_sha
659
659
        new_refs = self.target.controldir.get_refs_container()
660
660
        return None, old_refs, new_refs
669
669
 
670
670
    def fetch(self, revision_id=None, find_ghosts=False,
671
671
              mapping=None, fetch_spec=None, branches=None, limit=None,
672
 
              include_tags=False, lossy=False):
 
672
              include_tags=False):
673
673
        if mapping is None:
674
674
            mapping = self.source.get_mapping()
675
675
        if revision_id is not None:
683
683
                    "Unsupported search result type %s" % recipe[0])
684
684
            args = heads
685
685
        if branches is not None:
686
 
            determine_wants = self.get_determine_wants_branches(
687
 
                branches, include_tags=include_tags)
 
686
            def determine_wants(refs):
 
687
                ret = []
 
688
                for name, value in viewitems(refs):
 
689
                    if value == ZERO_SHA:
 
690
                        continue
 
691
 
 
692
                    if name in branches or (include_tags and is_tag(name)):
 
693
                        ret.append(value)
 
694
                return ret
688
695
        elif fetch_spec is None and revision_id is None:
689
696
            determine_wants = self.determine_wants_all
690
697
        else:
691
698
            determine_wants = self.get_determine_wants_revids(
692
699
                args, include_tags=include_tags)
693
700
        wants_recorder = DetermineWantsRecorder(determine_wants)
694
 
        self.fetch_objects(wants_recorder, mapping, limit=limit, lossy=lossy)
695
 
        result = FetchResult()
696
 
        result.refs = wants_recorder.remote_refs
697
 
        return result
 
701
        self.fetch_objects(wants_recorder, mapping, limit=limit)
 
702
        return wants_recorder.remote_refs
698
703
 
699
 
    def get_determine_wants_revids(self, revids, include_tags=False, tag_selector=None):
 
704
    def get_determine_wants_revids(self, revids, include_tags=False):
700
705
        wants = set()
701
706
        for revid in set(revids):
702
707
            if revid == NULL_REVISION:
703
708
                continue
704
709
            git_sha, mapping = self.source.lookup_bzr_revision_id(revid)
705
710
            wants.add(git_sha)
706
 
        return self.get_determine_wants_heads(wants, include_tags=include_tags, tag_selector=tag_selector)
707
 
 
708
 
    def get_determine_wants_branches(self, branches, include_tags=False):
709
 
        def determine_wants(refs):
710
 
            ret = []
711
 
            for name, value in refs.items():
712
 
                if value == ZERO_SHA:
713
 
                    continue
714
 
 
715
 
                if name.endswith(ANNOTATED_TAG_SUFFIX):
716
 
                    continue
717
 
 
718
 
                if name in branches or (include_tags and is_tag(name)):
719
 
                    ret.append(value)
720
 
            return ret
721
 
        return determine_wants
 
711
        return self.get_determine_wants_heads(wants, include_tags=include_tags)
722
712
 
723
713
    def determine_wants_all(self, refs):
724
714
        potential = set([
736
726
        if limit is not None:
737
727
            raise FetchLimitUnsupported(self)
738
728
        from .remote import DefaultProgressReporter
739
 
        with ui.ui_factory.nested_progress_bar() as pb:
740
 
            progress = DefaultProgressReporter(pb).progress
 
729
        pb = ui.ui_factory.nested_progress_bar()
 
730
        progress = DefaultProgressReporter(pb).progress
 
731
        try:
741
732
            refs = self.source._git.fetch(
742
733
                self.target._git, determine_wants,
743
734
                progress=progress)
 
735
        finally:
 
736
            pb.finished()
744
737
        return (None, None, refs)
745
738
 
746
739
    @staticmethod