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

Add check-all target.

Show diffs side-by-side

added added

removed removed

Lines of Context:
branch.py
17
17
 
18
18
"""An adapter between a Git Branch and a Bazaar Branch"""
19
19
 
 
20
from collections import defaultdict
 
21
 
20
22
from dulwich.objects import (
21
23
    Commit,
22
24
    Tag,
 
25
    ZERO_SHA,
23
26
    )
24
27
 
25
28
from bzrlib import (
27
30
    bzrdir,
28
31
    config,
29
32
    errors,
30
 
    repository,
 
33
    repository as _mod_repository,
31
34
    revision,
32
35
    tag,
33
36
    transport,
51
54
    NoSuchRef,
52
55
    )
53
56
from bzrlib.plugins.git.refs import (
 
57
    branch_name_to_ref,
 
58
    extract_tags,
 
59
    is_tag,
54
60
    ref_to_branch_name,
55
 
    extract_tags,
 
61
    ref_to_tag_name,
56
62
    tag_name_to_ref,
 
63
    UnpeelMap,
57
64
    )
58
65
 
59
66
from bzrlib.foreign import ForeignBranch
76
83
        return self._lookup_revno(self.new_revid)
77
84
 
78
85
 
79
 
class LocalGitTagDict(tag.BasicTags):
80
 
    """Dictionary with tags in a local repository."""
 
86
class GitTags(tag.BasicTags):
 
87
    """Ref-based tag dictionary."""
81
88
 
82
89
    def __init__(self, branch):
83
90
        self.branch = branch
84
91
        self.repository = branch.repository
85
92
 
 
93
    def get_refs(self):
 
94
        raise NotImplementedError(self.get_refs)
 
95
 
 
96
    def _iter_tag_refs(self, refs):
 
97
        raise NotImplementedError(self._iter_tag_refs)
 
98
 
 
99
    def _merge_to_git(self, to_tags, refs, overwrite=False):
 
100
        target_repo = to_tags.repository
 
101
        conflicts = []
 
102
        for k, v in refs.iteritems():
 
103
            if not is_tag(k):
 
104
                continue
 
105
            if overwrite or not k in target_repo._git.refs:
 
106
                target_repo._git.refs[k] = v
 
107
            elif target_repo._git.refs[k] == v:
 
108
                pass
 
109
            else:
 
110
                conflicts.append((ref_to_tag_name(k), v, target_repo.refs[k]))
 
111
        return conflicts
 
112
 
 
113
    def _merge_to_non_git(self, to_tags, refs, overwrite=False):
 
114
        unpeeled_map = defaultdict(set)
 
115
        conflicts = []
 
116
        result = dict(to_tags.get_tag_dict())
 
117
        for n, peeled, unpeeled, bzr_revid in self._iter_tag_refs(refs):
 
118
            if unpeeled is not None:
 
119
                unpeeled_map[peeled].add(unpeeled)
 
120
            if n not in result or overwrite:
 
121
                result[n] = bzr_revid
 
122
            elif result[n] == bzr_revid:
 
123
                pass
 
124
            else:
 
125
                conflicts.append((n, result[n], bzr_revid))
 
126
        to_tags._set_tag_dict(result)
 
127
        if len(unpeeled_map) > 0:
 
128
            map_file = UnpeelMap.from_repository(to_tags.branch.repository)
 
129
            map_file.update(unpeeled_map)
 
130
            map_file.save_in_repository(to_tags.branch.repository)
 
131
        return conflicts
 
132
 
 
133
    def merge_to(self, to_tags, overwrite=False, ignore_master=False,
 
134
                 source_refs=None):
 
135
        """See Tags.merge_to."""
 
136
        if source_refs is None:
 
137
            source_refs = self.get_refs()
 
138
        if self == to_tags:
 
139
            return
 
140
        if isinstance(to_tags, GitTags):
 
141
            return self._merge_to_git(to_tags, source_refs,
 
142
                                      overwrite=overwrite)
 
143
        else:
 
144
            if ignore_master:
 
145
                master = None
 
146
            else:
 
147
                master = to_tags.branch.get_master_branch()
 
148
            conflicts = self._merge_to_non_git(to_tags, source_refs,
 
149
                                              overwrite=overwrite)
 
150
            if master is not None:
 
151
                conflicts += self.merge_to(master.tags, overwrite=overwrite,
 
152
                                           source_refs=source_refs,
 
153
                                           ignore_master=ignore_master)
 
154
            return conflicts
 
155
 
86
156
    def get_tag_dict(self):
87
157
        ret = {}
88
 
        for k,v in extract_tags(self.repository._git.get_refs()).iteritems():
 
158
        refs = self.get_refs()
 
159
        for (name, peeled, unpeeled, bzr_revid) in self._iter_tag_refs(refs):
 
160
            ret[name] = bzr_revid
 
161
        return ret
 
162
 
 
163
 
 
164
class LocalGitTagDict(GitTags):
 
165
    """Dictionary with tags in a local repository."""
 
166
 
 
167
    def __init__(self, branch):
 
168
        super(LocalGitTagDict, self).__init__(branch)
 
169
        self.refs = self.repository._git.refs
 
170
 
 
171
    def get_refs(self):
 
172
        return self.repository._git.get_refs()
 
173
 
 
174
    def _iter_tag_refs(self, refs):
 
175
        """Iterate over the tag refs.
 
176
 
 
177
        :param refs: Refs dictionary (name -> git sha1)
 
178
        :return: iterator over (name, peeled_sha1, unpeeled_sha1, bzr_revid)
 
179
        """
 
180
        for k, (peeled, unpeeled) in extract_tags(refs).iteritems():
89
181
            try:
90
 
                obj = self.repository._git[v]
 
182
                obj = self.repository._git[peeled]
91
183
            except KeyError:
92
 
                mutter("Tag %s points at unknown object %s, ignoring", v, obj)
 
184
                mutter("Tag %s points at unknown object %s, ignoring", peeled,
 
185
                       obj)
93
186
                continue
 
187
            # FIXME: this shouldn't really be necessary, the repository
 
188
            # already should have these unpeeled.
94
189
            while isinstance(obj, Tag):
95
 
                v = obj.object[1]
96
 
                obj = self.repository._git[v]
 
190
                peeled = obj.object[1]
 
191
                obj = self.repository._git[peeled]
97
192
            if not isinstance(obj, Commit):
98
193
                mutter("Tag %s points at object %r that is not a commit, "
99
194
                       "ignoring", k, obj)
100
195
                continue
101
 
            ret[k] = self.branch.lookup_foreign_revision_id(v)
102
 
        return ret
 
196
            yield (k, peeled, unpeeled,
 
197
                   self.branch.lookup_foreign_revision_id(peeled))
103
198
 
104
199
    def _set_tag_dict(self, to_dict):
105
 
        extra = set(self.repository._git.get_refs().keys())
 
200
        extra = set(self.get_refs().keys())
106
201
        for k, revid in to_dict.iteritems():
107
202
            name = tag_name_to_ref(k)
108
203
            if name in extra:
109
204
                extra.remove(name)
110
205
            self.set_tag(k, revid)
111
206
        for name in extra:
112
 
            if name.startswith("refs/tags/"):
 
207
            if is_tag(name):
113
208
                del self.repository._git[name]
114
209
 
115
210
    def set_tag(self, name, revid):
116
 
        self.repository._git.refs[tag_name_to_ref(name)], _ = \
 
211
        self.refs[tag_name_to_ref(name)], _ = \
117
212
            self.branch.lookup_bzr_revision_id(revid)
118
213
 
119
214
 
120
 
class DictTagDict(LocalGitTagDict):
 
215
class DictTagDict(tag.BasicTags):
121
216
 
122
217
    def __init__(self, branch, tags):
123
218
        super(DictTagDict, self).__init__(branch)
138
233
    def supports_tags(self):
139
234
        return True
140
235
 
 
236
    def supports_leaving_lock(self):
 
237
        return False
 
238
 
 
239
    @property
 
240
    def _matchingbzrdir(self):
 
241
        from bzrlib.plugins.git.dir import LocalGitControlDirFormat
 
242
        return LocalGitControlDirFormat()
 
243
 
141
244
    def get_foreign_tests_branch_factory(self):
142
245
        from bzrlib.plugins.git.tests.test_branch import ForeignTestsBranchFactory
143
246
        return ForeignTestsBranchFactory()
149
252
        else:
150
253
            return LocalGitTagDict(branch)
151
254
 
 
255
    def initialize(self, a_bzrdir, name=None, repository=None):
 
256
        from bzrlib.plugins.git.dir import LocalGitDir
 
257
        if not isinstance(a_bzrdir, LocalGitDir):
 
258
            raise errors.IncompatibleFormat(self, a_bzrdir._format)
 
259
        if repository is None:
 
260
            repository = a_bzrdir.open_repository()
 
261
        ref = branch_name_to_ref(name, "HEAD")
 
262
        repository._git[ref] = ZERO_SHA
 
263
        return LocalGitBranch(a_bzrdir, repository, ref, a_bzrdir._lockfiles)
 
264
 
152
265
 
153
266
class GitReadLock(object):
154
267
 
165
278
class GitBranch(ForeignBranch):
166
279
    """An adapter to git repositories for bzr Branch objects."""
167
280
 
 
281
    @property
 
282
    def control_transport(self):
 
283
        return self.bzrdir.control_transport
 
284
 
168
285
    def __init__(self, bzrdir, repository, ref, lockfiles, tagsdict=None):
169
286
        self.repository = repository
170
287
        self._format = GitBranchFormat()
208
325
            self.ref or "HEAD")
209
326
 
210
327
    def generate_revision_history(self, revid, old_revid=None):
211
 
        # FIXME: Check that old_revid is in the ancestry of revid
212
 
        newhead, self.mapping = self.mapping.revision_id_bzr_to_foreign(revid)
 
328
        if revid == NULL_REVISION:
 
329
            newhead = ZERO_SHA
 
330
        else:
 
331
            # FIXME: Check that old_revid is in the ancestry of revid
 
332
            newhead, self.mapping = self.mapping.revision_id_bzr_to_foreign(revid)
213
333
        self._set_head(newhead)
214
334
 
215
335
    def lock_write(self):
265
385
class LocalGitBranch(GitBranch):
266
386
    """A local Git branch."""
267
387
 
268
 
    def __init__(self, bzrdir, repository, name, lockfiles, tagsdict=None):
269
 
        super(LocalGitBranch, self).__init__(bzrdir, repository, name,
 
388
    def __init__(self, bzrdir, repository, ref, lockfiles, tagsdict=None):
 
389
        super(LocalGitBranch, self).__init__(bzrdir, repository, ref,
270
390
              lockfiles, tagsdict)
271
391
        refs = repository._git.get_refs()
272
 
        if not (name in refs.keys() or "HEAD" in refs.keys()):
 
392
        if not (ref in refs.keys() or "HEAD" in refs.keys()):
273
393
            raise errors.NotBranchError(self.base)
274
394
 
275
395
    def create_checkout(self, to_location, revision_id=None, lightweight=False,
351
471
        return True
352
472
 
353
473
 
 
474
def _quick_lookup_revno(local_branch, remote_branch, revid):
 
475
    assert isinstance(revid, str), "was %r" % revid
 
476
    # Try in source branch first, it'll be faster
 
477
    try:
 
478
        return local_branch.revision_id_to_revno(revid)
 
479
    except errors.NoSuchRevision:
 
480
        graph = local_branch.repository.get_graph()
 
481
        try:
 
482
            return graph.find_distance_to_null(revid)
 
483
        except errors.GhostRevisionsHaveNoRevno:
 
484
            # FIXME: Check using graph.find_distance_to_null() ?
 
485
            return remote_branch.revision_id_to_revno(revid)
 
486
 
 
487
 
354
488
class GitBranchPullResult(branch.PullResult):
355
489
 
356
490
    def __init__(self):
371
505
        self._show_tag_conficts(to_file)
372
506
 
373
507
    def _lookup_revno(self, revid):
374
 
        assert isinstance(revid, str), "was %r" % revid
375
 
        # Try in source branch first, it'll be faster
376
 
        try:
377
 
            return self.source_branch.revision_id_to_revno(revid)
378
 
        except errors.NoSuchRevision:
379
 
            # FIXME: Check using graph.find_distance_to_null() ?
380
 
            return self.target_branch.revision_id_to_revno(revid)
 
508
        return _quick_lookup_revno(self.target_branch, self.source_branch, revid)
381
509
 
382
510
    def _get_old_revno(self):
383
511
        if self._old_revno is not None:
403
531
class GitBranchPushResult(branch.BranchPushResult):
404
532
 
405
533
    def _lookup_revno(self, revid):
406
 
        assert isinstance(revid, str), "was %r" % revid
407
 
        # Try in source branch first, it'll be faster
408
 
        try:
409
 
            return self.source_branch.revision_id_to_revno(revid)
410
 
        except errors.NoSuchRevision:
411
 
            # FIXME: Check using graph.find_distance_to_null() ?
412
 
            return self.target_branch.revision_id_to_revno(revid)
 
534
        return _quick_lookup_revno(self.source_branch, self.target_branch, revid)
413
535
 
414
536
    @property
415
537
    def old_revno(self):
417
539
 
418
540
    @property
419
541
    def new_revno(self):
 
542
        new_original_revno = getattr(self, "new_original_revno", None)
 
543
        if new_original_revno:
 
544
            return new_original_revno
 
545
        if getattr(self, "new_original_revid", None) is not None:
 
546
            return self._lookup_revno(self.new_original_revid)
420
547
        return self._lookup_revno(self.new_revid)
421
548
 
422
549
 
425
552
 
426
553
    @staticmethod
427
554
    def _get_branch_formats_to_test():
428
 
        return []
 
555
        try:
 
556
            default_format = branch.format_registry.get_default()
 
557
        except AttributeError:
 
558
            default_format = branch.BranchFormat._default_format
 
559
        return [
 
560
            (GitBranchFormat(), GitBranchFormat()),
 
561
            (GitBranchFormat(), default_format)]
429
562
 
430
563
    @classmethod
431
564
    def _get_interrepo(self, source, target):
432
 
        return repository.InterRepository.get(source.repository,
433
 
            target.repository)
 
565
        return _mod_repository.InterRepository.get(source.repository, target.repository)
434
566
 
435
567
    @classmethod
436
568
    def is_compatible(cls, source, target):
438
570
                not isinstance(target, GitBranch) and
439
571
                (getattr(cls._get_interrepo(source, target), "fetch_objects", None) is not None))
440
572
 
441
 
    def _update_revisions(self, stop_revision=None, overwrite=False,
442
 
        graph=None, limit=None):
443
 
        """Like InterBranch.update_revisions(), but with additions.
 
573
    def fetch(self, stop_revision=None, fetch_tags=True):
 
574
        self.fetch_objects(stop_revision, fetch_tags=fetch_tags)
444
575
 
445
 
        Compared to the `update_revisions()` below, this function takes a
446
 
        `limit` argument that limits how many git commits will be converted
447
 
        and returns the new git head.
448
 
        """
 
576
    def fetch_objects(self, stop_revision, fetch_tags):
449
577
        interrepo = self._get_interrepo(self.source, self.target)
450
578
        def determine_wants(heads):
451
579
            if self.source.ref is not None and not self.source.ref in heads:
452
580
                raise NoSuchRef(self.source.ref, heads.keys())
453
 
            if stop_revision is not None:
454
 
                self._last_revid = stop_revision
455
 
                head, mapping = self.source.repository.lookup_bzr_revision_id(
456
 
                    stop_revision)
457
 
            else:
 
581
 
 
582
            if stop_revision is None:
458
583
                if self.source.ref is not None:
459
584
                    head = heads[self.source.ref]
460
585
                else:
461
586
                    head = heads["HEAD"]
462
587
                self._last_revid = self.source.lookup_foreign_revision_id(head)
463
 
            if self.target.repository.has_revision(self._last_revid):
464
 
                return []
465
 
            return [head]
 
588
            else:
 
589
                self._last_revid = stop_revision
 
590
            real = interrepo.get_determine_wants_revids(
 
591
                [self._last_revid], include_tags=fetch_tags)
 
592
            return real(heads)
466
593
        pack_hint, head, refs = interrepo.fetch_objects(
467
 
            determine_wants, self.source.mapping, limit=limit)
 
594
            determine_wants, self.source.mapping)
468
595
        if (pack_hint is not None and
469
596
            self.target.repository._format.pack_compresses):
470
597
            self.target.repository.pack(hint=pack_hint)
471
 
        if head is not None:
472
 
            self._last_revid = self.source.lookup_foreign_revision_id(head)
 
598
        return head, refs
 
599
 
 
600
    def update_revisions(self, stop_revision=None, overwrite=False,
 
601
                         graph=None):
 
602
        """See InterBranch.update_revisions()."""
 
603
        head, refs = self.fetch_objects(stop_revision, fetch_tags=True)
473
604
        if overwrite:
474
605
            prev_last_revid = None
475
606
        else:
476
607
            prev_last_revid = self.target.last_revision()
477
608
        self.target.generate_revision_history(self._last_revid,
478
 
            prev_last_revid)
479
 
        return head
480
 
 
481
 
    def update_revisions(self, stop_revision=None, overwrite=False,
482
 
                         graph=None):
483
 
        """See InterBranch.update_revisions()."""
484
 
        self._update_revisions(stop_revision, overwrite, graph)
 
609
            prev_last_revid, self.source)
 
610
        return head, refs
485
611
 
486
612
    def pull(self, overwrite=False, stop_revision=None,
487
613
             possible_transports=None, _hook_master=None, run_hooks=True,
488
 
             _override_hook_target=None, local=False, limit=None):
 
614
             _override_hook_target=None, local=False):
489
615
        """See Branch.pull.
490
616
 
491
617
        :param _hook_master: Private parameter - set the branch to
495
621
            so it should not run its hooks.
496
622
        :param _override_hook_target: Private parameter - set the branch to be
497
623
            supplied as the target_branch to pull hooks.
498
 
        :param limit: Only import this many revisons.  `None`, the default,
499
 
            means import all revisions.
500
624
        """
501
625
        # This type of branch can't be bound.
502
626
        if local:
514
638
            graph = self.target.repository.get_graph(self.source.repository)
515
639
            (result.old_revno, result.old_revid) = \
516
640
                self.target.last_revision_info()
517
 
            result.new_git_head = self._update_revisions(
518
 
                stop_revision, overwrite=overwrite, graph=graph, limit=limit)
 
641
            result.new_git_head, remote_refs = self.update_revisions(
 
642
                stop_revision, overwrite=overwrite, graph=graph)
519
643
            result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
520
644
                overwrite)
521
645
            (result.new_revno, result.new_revid) = \
539
663
        result.target_branch = self.target
540
664
        graph = self.target.repository.get_graph(self.source.repository)
541
665
        result.old_revno, result.old_revid = self.target.last_revision_info()
542
 
        result.new_git_head = self._update_revisions(
 
666
        result.new_git_head, remote_refs = self.update_revisions(
543
667
            stop_revision, overwrite=overwrite, graph=graph)
544
668
        result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
545
669
            overwrite)
556
680
 
557
681
    @staticmethod
558
682
    def _get_branch_formats_to_test():
 
683
        # FIXME
559
684
        return []
560
685
 
561
686
    @classmethod
565
690
                isinstance(target, RemoteGitBranch))
566
691
 
567
692
    def _basic_push(self, overwrite=False, stop_revision=None):
568
 
        from dulwich.protocol import ZERO_SHA
569
693
        result = GitBranchPushResult()
570
694
        result.source_branch = self.source
571
695
        result.target_branch = self.target
589
713
 
590
714
    @staticmethod
591
715
    def _get_branch_formats_to_test():
 
716
        # FIXME
592
717
        return []
593
718
 
594
719
    @classmethod
604
729
        result.old_revid = self.target.last_revision()
605
730
        refs, stop_revision = self.update_refs(stop_revision)
606
731
        self.target.generate_revision_history(stop_revision, result.old_revid)
607
 
        self.update_tags(refs)
 
732
        result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
 
733
            source_refs=refs, overwrite=overwrite)
608
734
        result.new_revid = self.target.last_revision()
609
735
        return result
610
736
 
611
 
    def update_tags(self, refs):
612
 
        for name, v in extract_tags(refs).iteritems():
613
 
            revid = self.target.lookup_foreign_revision_id(v)
614
 
            self.target.tags.set_tag(name, revid)
615
 
 
616
737
    def update_refs(self, stop_revision=None):
617
 
        interrepo = repository.InterRepository.get(self.source.repository,
 
738
        interrepo = _mod_repository.InterRepository.get(self.source.repository,
618
739
            self.target.repository)
619
740
        if stop_revision is None:
620
741
            refs = interrepo.fetch(branches=["HEAD"])
634
755
        result.old_revid = self.target.last_revision()
635
756
        refs, stop_revision = self.update_refs(stop_revision)
636
757
        self.target.generate_revision_history(stop_revision, result.old_revid)
637
 
        self.update_tags(refs)
 
758
        result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
 
759
            overwrite=overwrite, source_refs=refs)
638
760
        result.new_revid = self.target.last_revision()
639
761
        return result
640
762
 
644
766
 
645
767
    def __init__(self, source, target):
646
768
        super(InterToGitBranch, self).__init__(source, target)
647
 
        self.interrepo = repository.InterRepository.get(source.repository,
 
769
        self.interrepo = _mod_repository.InterRepository.get(source.repository,
648
770
                                           target.repository)
649
771
 
650
772
    @staticmethod
651
773
    def _get_branch_formats_to_test():
652
 
        return []
 
774
        try:
 
775
            default_format = branch.format_registry.get_default()
 
776
        except AttributeError:
 
777
            default_format = branch.BranchFormat._default_format
 
778
        return [(default_format, GitBranchFormat())]
653
779
 
654
780
    @classmethod
655
781
    def is_compatible(self, source, target):
661
787
 
662
788
    def _get_new_refs(self, stop_revision=None):
663
789
        if stop_revision is None:
664
 
            stop_revision = self.source.last_revision()
 
790
            (stop_revno, stop_revision) = self.source.last_revision_info()
665
791
        assert type(stop_revision) is str
666
792
        main_ref = self.target.ref or "refs/heads/master"
667
793
        refs = { main_ref: (None, stop_revision) }
668
794
        for name, revid in self.source.tags.get_tag_dict().iteritems():
669
795
            if self.source.repository.has_revision(revid):
670
796
                refs[tag_name_to_ref(name)] = (None, revid)
671
 
        return refs, main_ref
 
797
        return refs, main_ref, (stop_revno, stop_revision)
672
798
 
673
799
    def pull(self, overwrite=False, stop_revision=None, local=False,
674
 
             possible_transports=None):
675
 
        from dulwich.protocol import ZERO_SHA
 
800
             possible_transports=None, run_hooks=True):
676
801
        result = GitBranchPullResult()
677
802
        result.source_branch = self.source
678
803
        result.target_branch = self.target
679
 
        new_refs, main_ref = self._get_new_refs(stop_revision)
 
804
        new_refs, main_ref, stop_revinfo = self._get_new_refs(stop_revision)
680
805
        def update_refs(old_refs):
681
806
            refs = dict(old_refs)
682
807
            # FIXME: Check for diverged branches
683
808
            refs.update(new_refs)
684
809
            return refs
685
 
        old_refs, new_refs = self.interrepo.fetch_refs(update_refs)
686
 
        result.old_revid = self.target.lookup_foreign_revision_id(
687
 
            old_refs.get(main_ref, ZERO_SHA))
688
 
        result.new_revid = new_refs[main_ref]
 
810
        try:
 
811
            old_refs, new_refs = self.interrepo.fetch_refs(update_refs)
 
812
        except NoPushSupport:
 
813
            raise errors.NoRepositoryPresent(self.source, self.target)
 
814
        (result.old_revid, old_sha1) = old_refs.get(main_ref, (ZERO_SHA, NULL_REVISION))
 
815
        if result.old_revid is None:
 
816
            result.old_revid = self.target.lookup_foreign_revision_id(old_sha1)
 
817
        result.new_revid = new_refs[main_ref][1]
689
818
        return result
690
819
 
691
820
    def push(self, overwrite=False, stop_revision=None,
692
821
             _override_hook_source_branch=None):
693
 
        from dulwich.protocol import ZERO_SHA
694
822
        result = GitBranchPushResult()
695
823
        result.source_branch = self.source
696
824
        result.target_branch = self.target
697
 
        new_refs, main_ref = self._get_new_refs(stop_revision)
 
825
        new_refs, main_ref, stop_revinfo = self._get_new_refs(stop_revision)
698
826
        def update_refs(old_refs):
699
827
            refs = dict(old_refs)
700
828
            # FIXME: Check for diverged branches
701
829
            refs.update(new_refs)
702
830
            return refs
703
 
        old_refs, new_refs = self.interrepo.fetch_refs(update_refs)
 
831
        try:
 
832
            old_refs, new_refs = self.interrepo.fetch_refs(update_refs)
 
833
        except NoPushSupport:
 
834
            raise errors.NoRepositoryPresent(self.source, self.target)
704
835
        (result.old_revid, old_sha1) = old_refs.get(main_ref, (ZERO_SHA, NULL_REVISION))
705
836
        if result.old_revid is None:
706
837
            result.old_revid = self.target.lookup_foreign_revision_id(old_sha1)
707
 
        result.new_revid = new_refs[main_ref]
 
838
        result.new_revid = new_refs[main_ref][1]
708
839
        return result
709
840
 
710
841
    def lossy_push(self, stop_revision=None):
711
842
        result = GitBranchPushResult()
712
843
        result.source_branch = self.source
713
844
        result.target_branch = self.target
714
 
        new_refs, main_ref = self._get_new_refs(stop_revision)
 
845
        new_refs, main_ref, stop_revinfo = self._get_new_refs(stop_revision)
715
846
        def update_refs(old_refs):
716
847
            refs = dict(old_refs)
717
848
            # FIXME: Check for diverged branches
721
852
            update_refs)
722
853
        result.old_revid = old_refs.get(self.target.ref, (None, NULL_REVISION))[1]
723
854
        result.new_revid = new_refs[main_ref][1]
 
855
        (result.new_original_revno, result.new_original_revid) = stop_revinfo
724
856
        return result
725
857
 
726
858