/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

Support read locking object stores.

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
 
159
272
class GitWriteLock(object):
160
273
 
161
274
    def __init__(self, unlock):
 
275
        self.branch_token = None
162
276
        self.unlock = unlock
163
277
 
164
278
 
165
279
class GitBranch(ForeignBranch):
166
280
    """An adapter to git repositories for bzr Branch objects."""
167
281
 
 
282
    @property
 
283
    def control_transport(self):
 
284
        return self.bzrdir.control_transport
 
285
 
168
286
    def __init__(self, bzrdir, repository, ref, lockfiles, tagsdict=None):
169
287
        self.repository = repository
170
288
        self._format = GitBranchFormat()
208
326
            self.ref or "HEAD")
209
327
 
210
328
    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)
 
329
        if revid == NULL_REVISION:
 
330
            newhead = ZERO_SHA
 
331
        else:
 
332
            # FIXME: Check that old_revid is in the ancestry of revid
 
333
            newhead, self.mapping = self.mapping.revision_id_bzr_to_foreign(revid)
213
334
        self._set_head(newhead)
214
335
 
215
 
    def lock_write(self):
 
336
    def lock_write(self, token=None):
 
337
        if token is not None:
 
338
            raise errors.TokenLockingNotSupported(self)
216
339
        self.control_files.lock_write()
217
340
        return GitWriteLock(self.unlock)
218
341
 
265
388
class LocalGitBranch(GitBranch):
266
389
    """A local Git branch."""
267
390
 
268
 
    def __init__(self, bzrdir, repository, name, lockfiles, tagsdict=None):
269
 
        super(LocalGitBranch, self).__init__(bzrdir, repository, name,
 
391
    def __init__(self, bzrdir, repository, ref, lockfiles, tagsdict=None):
 
392
        super(LocalGitBranch, self).__init__(bzrdir, repository, ref,
270
393
              lockfiles, tagsdict)
271
394
        refs = repository._git.get_refs()
272
 
        if not (name in refs.keys() or "HEAD" in refs.keys()):
 
395
        if not (ref in refs.keys() or "HEAD" in refs.keys()):
273
396
            raise errors.NotBranchError(self.base)
274
397
 
275
398
    def create_checkout(self, to_location, revision_id=None, lightweight=False,
351
474
        return True
352
475
 
353
476
 
 
477
def _quick_lookup_revno(local_branch, remote_branch, revid):
 
478
    assert isinstance(revid, str), "was %r" % revid
 
479
    # Try in source branch first, it'll be faster
 
480
    try:
 
481
        return local_branch.revision_id_to_revno(revid)
 
482
    except errors.NoSuchRevision:
 
483
        graph = local_branch.repository.get_graph()
 
484
        try:
 
485
            return graph.find_distance_to_null(revid)
 
486
        except errors.GhostRevisionsHaveNoRevno:
 
487
            # FIXME: Check using graph.find_distance_to_null() ?
 
488
            return remote_branch.revision_id_to_revno(revid)
 
489
 
 
490
 
354
491
class GitBranchPullResult(branch.PullResult):
355
492
 
356
493
    def __init__(self):
371
508
        self._show_tag_conficts(to_file)
372
509
 
373
510
    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)
 
511
        return _quick_lookup_revno(self.target_branch, self.source_branch,
 
512
                revid)
381
513
 
382
514
    def _get_old_revno(self):
383
515
        if self._old_revno is not None:
403
535
class GitBranchPushResult(branch.BranchPushResult):
404
536
 
405
537
    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)
 
538
        return _quick_lookup_revno(self.source_branch, self.target_branch,
 
539
            revid)
413
540
 
414
541
    @property
415
542
    def old_revno(self):
417
544
 
418
545
    @property
419
546
    def new_revno(self):
 
547
        new_original_revno = getattr(self, "new_original_revno", None)
 
548
        if new_original_revno:
 
549
            return new_original_revno
 
550
        if getattr(self, "new_original_revid", None) is not None:
 
551
            return self._lookup_revno(self.new_original_revid)
420
552
        return self._lookup_revno(self.new_revid)
421
553
 
422
554
 
425
557
 
426
558
    @staticmethod
427
559
    def _get_branch_formats_to_test():
428
 
        return []
 
560
        try:
 
561
            default_format = branch.format_registry.get_default()
 
562
        except AttributeError:
 
563
            default_format = branch.BranchFormat._default_format
 
564
        return [
 
565
            (GitBranchFormat(), GitBranchFormat()),
 
566
            (GitBranchFormat(), default_format)]
429
567
 
430
568
    @classmethod
431
569
    def _get_interrepo(self, source, target):
432
 
        return repository.InterRepository.get(source.repository,
433
 
            target.repository)
 
570
        return _mod_repository.InterRepository.get(source.repository, target.repository)
434
571
 
435
572
    @classmethod
436
573
    def is_compatible(cls, source, target):
438
575
                not isinstance(target, GitBranch) and
439
576
                (getattr(cls._get_interrepo(source, target), "fetch_objects", None) is not None))
440
577
 
441
 
    def _update_revisions(self, stop_revision=None, overwrite=False,
442
 
        graph=None, limit=None):
443
 
        """Like InterBranch.update_revisions(), but with additions.
 
578
    def fetch(self, stop_revision=None, fetch_tags=True):
 
579
        self.fetch_objects(stop_revision, fetch_tags=fetch_tags)
444
580
 
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
 
        """
 
581
    def fetch_objects(self, stop_revision, fetch_tags):
449
582
        interrepo = self._get_interrepo(self.source, self.target)
450
583
        def determine_wants(heads):
451
584
            if self.source.ref is not None and not self.source.ref in heads:
452
585
                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:
 
586
 
 
587
            if stop_revision is None:
458
588
                if self.source.ref is not None:
459
589
                    head = heads[self.source.ref]
460
590
                else:
461
591
                    head = heads["HEAD"]
462
592
                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]
 
593
            else:
 
594
                self._last_revid = stop_revision
 
595
            real = interrepo.get_determine_wants_revids(
 
596
                [self._last_revid], include_tags=fetch_tags)
 
597
            return real(heads)
466
598
        pack_hint, head, refs = interrepo.fetch_objects(
467
 
            determine_wants, self.source.mapping, limit=limit)
 
599
            determine_wants, self.source.mapping)
468
600
        if (pack_hint is not None and
469
601
            self.target.repository._format.pack_compresses):
470
602
            self.target.repository.pack(hint=pack_hint)
471
 
        if head is not None:
472
 
            self._last_revid = self.source.lookup_foreign_revision_id(head)
 
603
        return head, refs
 
604
 
 
605
    def update_revisions(self, stop_revision=None, overwrite=False,
 
606
                         graph=None):
 
607
        """See InterBranch.update_revisions()."""
 
608
        head, refs = self.fetch_objects(stop_revision, fetch_tags=True)
473
609
        if overwrite:
474
610
            prev_last_revid = None
475
611
        else:
476
612
            prev_last_revid = self.target.last_revision()
477
613
        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)
 
614
            prev_last_revid, self.source)
 
615
        return head, refs
485
616
 
486
617
    def pull(self, overwrite=False, stop_revision=None,
487
618
             possible_transports=None, _hook_master=None, run_hooks=True,
488
 
             _override_hook_target=None, local=False, limit=None):
 
619
             _override_hook_target=None, local=False):
489
620
        """See Branch.pull.
490
621
 
491
622
        :param _hook_master: Private parameter - set the branch to
495
626
            so it should not run its hooks.
496
627
        :param _override_hook_target: Private parameter - set the branch to be
497
628
            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
629
        """
501
630
        # This type of branch can't be bound.
502
631
        if local:
514
643
            graph = self.target.repository.get_graph(self.source.repository)
515
644
            (result.old_revno, result.old_revid) = \
516
645
                self.target.last_revision_info()
517
 
            result.new_git_head = self._update_revisions(
518
 
                stop_revision, overwrite=overwrite, graph=graph, limit=limit)
 
646
            result.new_git_head, remote_refs = self.update_revisions(
 
647
                stop_revision, overwrite=overwrite, graph=graph)
519
648
            result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
520
649
                overwrite)
521
650
            (result.new_revno, result.new_revid) = \
539
668
        result.target_branch = self.target
540
669
        graph = self.target.repository.get_graph(self.source.repository)
541
670
        result.old_revno, result.old_revid = self.target.last_revision_info()
542
 
        result.new_git_head = self._update_revisions(
 
671
        result.new_git_head, remote_refs = self.update_revisions(
543
672
            stop_revision, overwrite=overwrite, graph=graph)
544
673
        result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
545
674
            overwrite)
551
680
    """InterBranch implementation that pulls between Git branches."""
552
681
 
553
682
 
554
 
class InterGitLocalRemoteBranch(InterGitBranch):
 
683
class InterLocalGitRemoteGitBranch(InterGitBranch):
555
684
    """InterBranch that copies from a local to a remote git branch."""
556
685
 
557
686
    @staticmethod
558
687
    def _get_branch_formats_to_test():
 
688
        # FIXME
559
689
        return []
560
690
 
561
691
    @classmethod
565
695
                isinstance(target, RemoteGitBranch))
566
696
 
567
697
    def _basic_push(self, overwrite=False, stop_revision=None):
568
 
        from dulwich.protocol import ZERO_SHA
569
698
        result = GitBranchPushResult()
570
699
        result.source_branch = self.source
571
700
        result.target_branch = self.target
584
713
        return result
585
714
 
586
715
 
587
 
class InterGitRemoteLocalBranch(InterGitBranch):
 
716
class InterGitLocalGitBranch(InterGitBranch):
588
717
    """InterBranch that copies from a remote to a local git branch."""
589
718
 
590
719
    @staticmethod
591
720
    def _get_branch_formats_to_test():
 
721
        # FIXME
592
722
        return []
593
723
 
594
724
    @classmethod
595
725
    def is_compatible(self, source, target):
596
 
        from bzrlib.plugins.git.remote import RemoteGitBranch
597
 
        return (isinstance(source, RemoteGitBranch) and
 
726
        return (isinstance(source, GitBranch) and
598
727
                isinstance(target, LocalGitBranch))
599
728
 
600
729
    def _basic_push(self, overwrite=False, stop_revision=None):
604
733
        result.old_revid = self.target.last_revision()
605
734
        refs, stop_revision = self.update_refs(stop_revision)
606
735
        self.target.generate_revision_history(stop_revision, result.old_revid)
607
 
        self.update_tags(refs)
 
736
        result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
 
737
            source_refs=refs, overwrite=overwrite)
608
738
        result.new_revid = self.target.last_revision()
609
739
        return result
610
740
 
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
741
    def update_refs(self, stop_revision=None):
617
 
        interrepo = repository.InterRepository.get(self.source.repository,
 
742
        interrepo = _mod_repository.InterRepository.get(self.source.repository,
618
743
            self.target.repository)
619
744
        if stop_revision is None:
620
745
            refs = interrepo.fetch(branches=["HEAD"])
634
759
        result.old_revid = self.target.last_revision()
635
760
        refs, stop_revision = self.update_refs(stop_revision)
636
761
        self.target.generate_revision_history(stop_revision, result.old_revid)
637
 
        self.update_tags(refs)
 
762
        result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
 
763
            overwrite=overwrite, source_refs=refs)
638
764
        result.new_revid = self.target.last_revision()
639
765
        return result
640
766
 
641
767
 
642
768
class InterToGitBranch(branch.GenericInterBranch):
643
 
    """InterBranch implementation that pulls from Git into bzr."""
 
769
    """InterBranch implementation that pulls into a Git branch."""
644
770
 
645
771
    def __init__(self, source, target):
646
772
        super(InterToGitBranch, self).__init__(source, target)
647
 
        self.interrepo = repository.InterRepository.get(source.repository,
 
773
        self.interrepo = _mod_repository.InterRepository.get(source.repository,
648
774
                                           target.repository)
649
775
 
650
776
    @staticmethod
651
777
    def _get_branch_formats_to_test():
652
 
        return []
 
778
        try:
 
779
            default_format = branch.format_registry.get_default()
 
780
        except AttributeError:
 
781
            default_format = branch.BranchFormat._default_format
 
782
        return [(default_format, GitBranchFormat())]
653
783
 
654
784
    @classmethod
655
785
    def is_compatible(self, source, target):
661
791
 
662
792
    def _get_new_refs(self, stop_revision=None):
663
793
        if stop_revision is None:
664
 
            stop_revision = self.source.last_revision()
 
794
            (stop_revno, stop_revision) = self.source.last_revision_info()
 
795
        else:
 
796
            stop_revno = self.source.revision_id_to_revno(stop_revision)
665
797
        assert type(stop_revision) is str
666
798
        main_ref = self.target.ref or "refs/heads/master"
667
799
        refs = { main_ref: (None, stop_revision) }
668
800
        for name, revid in self.source.tags.get_tag_dict().iteritems():
669
801
            if self.source.repository.has_revision(revid):
670
802
                refs[tag_name_to_ref(name)] = (None, revid)
671
 
        return refs, main_ref
 
803
        return refs, main_ref, (stop_revno, stop_revision)
672
804
 
673
805
    def pull(self, overwrite=False, stop_revision=None, local=False,
674
 
             possible_transports=None):
675
 
        from dulwich.protocol import ZERO_SHA
 
806
             possible_transports=None, run_hooks=True):
676
807
        result = GitBranchPullResult()
677
808
        result.source_branch = self.source
678
809
        result.target_branch = self.target
679
 
        new_refs, main_ref = self._get_new_refs(stop_revision)
 
810
        new_refs, main_ref, stop_revinfo = self._get_new_refs(stop_revision)
680
811
        def update_refs(old_refs):
681
812
            refs = dict(old_refs)
682
813
            # FIXME: Check for diverged branches
683
814
            refs.update(new_refs)
684
815
            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]
 
816
        try:
 
817
            old_refs, new_refs = self.interrepo.fetch_refs(update_refs)
 
818
        except NoPushSupport:
 
819
            raise errors.NoRoundtrippingSupport(self.source, self.target)
 
820
        (result.old_revid, old_sha1) = old_refs.get(main_ref, (ZERO_SHA, NULL_REVISION))
 
821
        if result.old_revid is None:
 
822
            result.old_revid = self.target.lookup_foreign_revision_id(old_sha1)
 
823
        result.new_revid = new_refs[main_ref][1]
689
824
        return result
690
825
 
691
826
    def push(self, overwrite=False, stop_revision=None,
692
827
             _override_hook_source_branch=None):
693
 
        from dulwich.protocol import ZERO_SHA
694
828
        result = GitBranchPushResult()
695
829
        result.source_branch = self.source
696
830
        result.target_branch = self.target
697
 
        new_refs, main_ref = self._get_new_refs(stop_revision)
 
831
        new_refs, main_ref, stop_revinfo = self._get_new_refs(stop_revision)
698
832
        def update_refs(old_refs):
699
833
            refs = dict(old_refs)
700
834
            # FIXME: Check for diverged branches
701
835
            refs.update(new_refs)
702
836
            return refs
703
 
        old_refs, new_refs = self.interrepo.fetch_refs(update_refs)
 
837
        try:
 
838
            old_refs, new_refs = self.interrepo.fetch_refs(update_refs)
 
839
        except NoPushSupport:
 
840
            raise errors.NoRoundtrippingSupport(self.source, self.target)
704
841
        (result.old_revid, old_sha1) = old_refs.get(main_ref, (ZERO_SHA, NULL_REVISION))
705
842
        if result.old_revid is None:
706
843
            result.old_revid = self.target.lookup_foreign_revision_id(old_sha1)
707
 
        result.new_revid = new_refs[main_ref]
 
844
        result.new_revid = new_refs[main_ref][1]
708
845
        return result
709
846
 
710
847
    def lossy_push(self, stop_revision=None):
711
848
        result = GitBranchPushResult()
712
849
        result.source_branch = self.source
713
850
        result.target_branch = self.target
714
 
        new_refs, main_ref = self._get_new_refs(stop_revision)
 
851
        new_refs, main_ref, stop_revinfo = self._get_new_refs(stop_revision)
715
852
        def update_refs(old_refs):
716
853
            refs = dict(old_refs)
717
854
            # FIXME: Check for diverged branches
721
858
            update_refs)
722
859
        result.old_revid = old_refs.get(self.target.ref, (None, NULL_REVISION))[1]
723
860
        result.new_revid = new_refs[main_ref][1]
 
861
        (result.new_original_revno, result.new_original_revid) = stop_revinfo
724
862
        return result
725
863
 
726
864
 
727
 
branch.InterBranch.register_optimiser(InterGitRemoteLocalBranch)
 
865
branch.InterBranch.register_optimiser(InterGitLocalGitBranch)
728
866
branch.InterBranch.register_optimiser(InterFromGitBranch)
729
867
branch.InterBranch.register_optimiser(InterToGitBranch)
730
 
branch.InterBranch.register_optimiser(InterGitLocalRemoteBranch)
 
868
branch.InterBranch.register_optimiser(InterLocalGitRemoteGitBranch)