1
# Copyright (C) 2007,2012 Canonical Ltd
2
# Copyright (C) 2009-2018 Jelmer Vernooij <jelmer@jelmer.uk>
4
# This program is free software; you can redistribute it and/or modify
5
# it under the terms of the GNU General Public License as published by
6
# the Free Software Foundation; either version 2 of the License, or
7
# (at your option) any later version.
9
# This program is distributed in the hope that it will be useful,
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12
# GNU General Public License for more details.
14
# You should have received a copy of the GNU General Public License
15
# along with this program; if not, write to the Free Software
16
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
"""An adapter between a Git Branch and a Bazaar Branch"""
22
from io import BytesIO
23
from collections import defaultdict
25
from dulwich.config import (
26
ConfigFile as GitConfigFile,
30
from dulwich.objects import (
34
from dulwich.repo import check_ref_format
42
repository as _mod_repository,
48
from ..foreign import ForeignBranch
49
from ..revision import (
65
from .mapping import (
77
remote_refs_dict_to_tag_refs,
80
from .unpeel_map import (
89
def _calculate_revnos(branch):
90
if branch._format.stores_revno():
92
config = branch.get_config_stack()
93
return config.get('calculate_revnos')
96
class GitPullResult(branch.PullResult):
97
"""Result of a pull from a Git branch."""
99
def _lookup_revno(self, revid):
100
if not isinstance(revid, bytes):
101
raise TypeError(revid)
102
if not _calculate_revnos(self.target_branch):
104
# Try in source branch first, it'll be faster
105
with self.target_branch.lock_read():
106
return self.target_branch.revision_id_to_revno(revid)
110
return self._lookup_revno(self.old_revid)
114
return self._lookup_revno(self.new_revid)
117
class InterTagsFromGitToRemoteGit(InterTags):
120
def is_compatible(klass, source, target):
121
if not isinstance(source, GitTags):
123
if not isinstance(target, GitTags):
125
if getattr(target.branch.repository, "_git", None) is not None:
129
def merge(self, overwrite=False, ignore_master=False, selector=None):
130
if self.source.branch.repository.has_same_location(self.target.branch.repository):
134
source_tag_refs = self.source.branch.get_tag_refs()
137
def get_changed_refs(old_refs):
139
for ref_name, tag_name, peeled, unpeeled in (
140
source_tag_refs.iteritems()):
141
if selector and not selector(tag_name):
143
if old_refs.get(ref_name) == unpeeled:
145
elif overwrite or ref_name not in old_refs:
146
ret[ref_name] = unpeeled
147
updates[tag_name] = self.target.branch.repository.lookup_foreign_revision_id(
149
ref_to_tag_map[ref_name] = tag_name
150
self.target.branch._tag_refs = None
154
self.repository.lookup_foreign_revision_id(peeled),
155
self.target.branch.repository.lookup_foreign_revision_id(
156
old_refs[ref_name])))
158
result = self.target.branch.repository.controldir.send_pack(
159
get_changed_refs, lambda have, want: [])
160
if result is not None and not isinstance(result, dict):
161
for ref, error in result.ref_status.items():
163
warning('unable to update ref %s: %s',
165
del updates[ref_to_tag_map[ref]]
166
return updates, set(conflicts)
169
class InterTagsFromGitToLocalGit(InterTags):
172
def is_compatible(klass, source, target):
173
if not isinstance(source, GitTags):
175
if not isinstance(target, GitTags):
177
if getattr(target.branch.repository, "_git", None) is None:
181
def merge(self, overwrite=False, ignore_master=False, selector=None):
182
if self.source.branch.repository.has_same_location(self.target.branch.repository):
187
source_tag_refs = self.source.branch.get_tag_refs()
189
target_repo = self.target.branch.repository
191
for ref_name, tag_name, peeled, unpeeled in source_tag_refs:
192
if selector and not selector(tag_name):
194
if target_repo._git.refs.get(ref_name) == unpeeled:
196
elif overwrite or ref_name not in target_repo._git.refs:
198
updates[tag_name] = (
199
target_repo.lookup_foreign_revision_id(peeled))
201
trace.warning('%s does not point to a valid object',
204
except NotCommitError:
205
trace.warning('%s points to a non-commit object',
208
target_repo._git.refs[ref_name] = unpeeled or peeled
209
self.target.branch._tag_refs = None
212
source_revid = self.source.branch.repository.lookup_foreign_revision_id(
214
target_revid = target_repo.lookup_foreign_revision_id(
215
target_repo._git.refs[ref_name])
217
trace.warning('%s does not point to a valid object',
220
except NotCommitError:
221
trace.warning('%s points to a non-commit object',
224
conflicts.append((tag_name, source_revid, target_revid))
225
return updates, set(conflicts)
228
class InterTagsFromGitToNonGit(InterTags):
231
def is_compatible(klass, source, target):
232
if not isinstance(source, GitTags):
234
if isinstance(target, GitTags):
238
def merge(self, overwrite=False, ignore_master=False, selector=None):
239
"""See Tags.merge_to."""
240
source_tag_refs = self.source.branch.get_tag_refs()
244
master = self.target.branch.get_master_branch()
245
with contextlib.ExitStack() as es:
246
if master is not None:
247
es.enter_context(master.lock_write())
248
updates, conflicts = self._merge_to(
249
self.target, source_tag_refs, overwrite=overwrite,
251
if master is not None:
252
extra_updates, extra_conflicts = self._merge_to(
253
master.tags, overwrite=overwrite,
254
source_tag_refs=source_tag_refs,
255
ignore_master=ignore_master, selector=selector)
256
updates.update(extra_updates)
257
conflicts.update(extra_conflicts)
258
return updates, conflicts
260
def _merge_to(self, to_tags, source_tag_refs, overwrite=False,
262
unpeeled_map = defaultdict(set)
265
result = dict(to_tags.get_tag_dict())
266
for ref_name, tag_name, peeled, unpeeled in source_tag_refs:
267
if selector and not selector(tag_name):
269
if unpeeled is not None:
270
unpeeled_map[peeled].add(unpeeled)
272
bzr_revid = self.source.branch.lookup_foreign_revision_id(peeled)
273
except NotCommitError:
275
if result.get(tag_name) == bzr_revid:
277
elif tag_name not in result or overwrite:
278
result[tag_name] = bzr_revid
279
updates[tag_name] = bzr_revid
281
conflicts.append((tag_name, bzr_revid, result[tag_name]))
282
to_tags._set_tag_dict(result)
283
if len(unpeeled_map) > 0:
284
map_file = UnpeelMap.from_repository(to_tags.branch.repository)
285
map_file.update(unpeeled_map)
286
map_file.save_in_repository(to_tags.branch.repository)
287
return updates, set(conflicts)
290
InterTags.register_optimiser(InterTagsFromGitToRemoteGit)
291
InterTags.register_optimiser(InterTagsFromGitToLocalGit)
292
InterTags.register_optimiser(InterTagsFromGitToNonGit)
296
"""Ref-based tag dictionary."""
298
def __init__(self, branch):
300
self.repository = branch.repository
302
def get_tag_dict(self):
304
for (ref_name, tag_name, peeled, unpeeled) in (
305
self.branch.get_tag_refs()):
307
bzr_revid = self.branch.lookup_foreign_revision_id(peeled)
308
except NotCommitError:
311
ret[tag_name] = bzr_revid
314
def lookup_tag(self, tag_name):
315
"""Return the referent string of a tag"""
316
# TODO(jelmer): Replace with something more efficient for local tags.
317
td = self.get_tag_dict()
321
raise errors.NoSuchTag(tag_name)
324
class LocalGitTagDict(GitTags):
325
"""Dictionary with tags in a local repository."""
327
def __init__(self, branch):
328
super(LocalGitTagDict, self).__init__(branch)
329
self.refs = self.repository.controldir._git.refs
331
def _set_tag_dict(self, to_dict):
332
extra = set(self.refs.allkeys())
333
for k, revid in to_dict.items():
334
name = tag_name_to_ref(k)
338
self.set_tag(k, revid)
339
except errors.GhostTagsNotSupported:
343
del self.repository._git[name]
345
def set_tag(self, name, revid):
347
git_sha, mapping = self.branch.lookup_bzr_revision_id(revid)
348
except errors.NoSuchRevision:
349
raise errors.GhostTagsNotSupported(self)
350
self.refs[tag_name_to_ref(name)] = git_sha
351
self.branch._tag_refs = None
353
def delete_tag(self, name):
354
ref = tag_name_to_ref(name)
355
if ref not in self.refs:
356
raise errors.NoSuchTag(name)
358
self.branch._tag_refs = None
361
class GitBranchFormat(branch.BranchFormat):
363
def network_name(self):
366
def supports_tags(self):
369
def supports_leaving_lock(self):
372
def supports_tags_referencing_ghosts(self):
375
def tags_are_versioned(self):
378
def get_foreign_tests_branch_factory(self):
379
from .tests.test_branch import ForeignTestsBranchFactory
380
return ForeignTestsBranchFactory()
382
def make_tags(self, branch):
385
except AttributeError:
387
if getattr(branch.repository, "_git", None) is None:
388
from .remote import RemoteGitTagDict
389
return RemoteGitTagDict(branch)
391
return LocalGitTagDict(branch)
393
def initialize(self, a_controldir, name=None, repository=None,
394
append_revisions_only=None):
395
raise NotImplementedError(self.initialize)
397
def get_reference(self, controldir, name=None):
398
return controldir.get_branch_reference(name=name)
400
def set_reference(self, controldir, name, target):
401
return controldir.set_branch_reference(target, name)
403
def stores_revno(self):
404
"""True if this branch format store revision numbers."""
407
supports_reference_locations = False
410
class LocalGitBranchFormat(GitBranchFormat):
412
def get_format_description(self):
413
return 'Local Git Branch'
416
def _matchingcontroldir(self):
417
from .dir import LocalGitControlDirFormat
418
return LocalGitControlDirFormat()
420
def initialize(self, a_controldir, name=None, repository=None,
421
append_revisions_only=None):
422
from .dir import LocalGitDir
423
if not isinstance(a_controldir, LocalGitDir):
424
raise errors.IncompatibleFormat(self, a_controldir._format)
425
return a_controldir.create_branch(
426
repository=repository, name=name,
427
append_revisions_only=append_revisions_only)
430
class GitBranch(ForeignBranch):
431
"""An adapter to git repositories for bzr Branch objects."""
434
def control_transport(self):
435
return self._control_transport
438
def user_transport(self):
439
return self._user_transport
441
def __init__(self, controldir, repository, ref, format):
442
self.repository = repository
443
self._format = format
444
self.controldir = controldir
445
self._lock_mode = None
447
super(GitBranch, self).__init__(repository.get_mapping())
450
self._user_transport = controldir.user_transport.clone('.')
451
self._control_transport = controldir.control_transport.clone('.')
452
self._tag_refs = None
455
self.name = ref_to_branch_name(ref)
458
if self.ref is not None:
459
params = {"ref": urlutils.escape(self.ref)}
462
params = {"branch": urlutils.escape(self.name)}
463
for k, v in params.items():
464
self._user_transport.set_segment_parameter(k, v)
465
self._control_transport.set_segment_parameter(k, v)
466
self.base = controldir.user_transport.base
468
def _get_checkout_format(self, lightweight=False):
469
"""Return the most suitable metadir for a checkout of this branch.
470
Weaves are used if this branch's repository uses weaves.
473
return controldir.format_registry.make_controldir("git")
475
return controldir.format_registry.make_controldir("default")
477
def get_child_submit_format(self):
478
"""Return the preferred format of submissions to this branch."""
479
ret = self.get_config_stack().get("child_submit_format")
484
def get_config(self):
485
from .config import GitBranchConfig
486
return GitBranchConfig(self)
488
def get_config_stack(self):
489
from .config import GitBranchStack
490
return GitBranchStack(self)
492
def _get_nick(self, local=False, possible_master_transports=None):
493
"""Find the nick name for this branch.
497
if getattr(self.repository, '_git', None):
498
cs = self.repository._git.get_config_stack()
500
return cs.get((b"branch", self.name.encode('utf-8')),
501
b"nick").decode("utf-8")
504
return self.name or u"HEAD"
506
def _set_nick(self, nick):
507
cf = self.repository._git.get_config()
508
cf.set((b"branch", self.name.encode('utf-8')),
509
b"nick", nick.encode("utf-8"))
512
self.repository._git._put_named_file('config', f.getvalue())
514
nick = property(_get_nick, _set_nick)
517
return "<%s(%r, %r)>" % (self.__class__.__name__, self.repository.base,
520
def generate_revision_history(self, revid, last_rev=None,
522
if last_rev is not None:
523
graph = self.repository.get_graph()
524
if not graph.is_ancestor(last_rev, revid):
525
# our previous tip is not merged into stop_revision
526
raise errors.DivergedBranches(self, other_branch)
528
self.set_last_revision(revid)
530
def lock_write(self, token=None):
531
if token is not None:
532
raise errors.TokenLockingNotSupported(self)
534
if self._lock_mode == 'r':
535
raise errors.ReadOnlyError(self)
536
self._lock_count += 1
539
self._lock_mode = 'w'
541
self.repository.lock_write()
542
return lock.LogicalLockResult(self.unlock)
544
def leave_lock_in_place(self):
545
raise NotImplementedError(self.leave_lock_in_place)
547
def dont_leave_lock_in_place(self):
548
raise NotImplementedError(self.dont_leave_lock_in_place)
550
def get_stacked_on_url(self):
551
# Git doesn't do stacking (yet...)
552
raise branch.UnstackableBranchFormat(self._format, self.base)
554
def _get_push_origin(self, cs):
555
"""Get the name for the push origin.
557
The exact behaviour is documented in the git-config(1) manpage.
560
return cs.get((b'branch', self.name.encode('utf-8')), b'pushRemote')
563
return cs.get((b'branch', ), b'remote')
566
return cs.get((b'branch', self.name.encode('utf-8')), b'remote')
570
def _get_origin(self, cs):
572
return cs.get((b'branch', self.name.encode('utf-8')), b'remote')
576
def _get_related_push_branch(self, cs):
577
remote = self._get_push_origin(cs)
579
location = cs.get((b"remote", remote), b"url")
583
return git_url_to_bzr_url(location.decode('utf-8'), ref=self.ref)
585
def _get_related_merge_branch(self, cs):
586
remote = self._get_origin(cs)
588
location = cs.get((b"remote", remote), b"url")
593
ref = cs.get((b"branch", remote), b"merge")
597
return git_url_to_bzr_url(location.decode('utf-8'), ref=ref)
599
def _get_parent_location(self):
600
"""See Branch.get_parent()."""
601
cs = self.repository._git.get_config_stack()
602
return self._get_related_merge_branch(cs)
604
def _write_git_config(self, cs):
607
self.repository._git._put_named_file('config', f.getvalue())
609
def set_parent(self, location):
610
cs = self.repository._git.get_config()
611
remote = self._get_origin(cs)
612
this_url = urlutils.strip_segment_parameters(self.user_url)
613
target_url, branch, ref = bzr_url_to_git_url(location)
614
location = urlutils.relative_url(this_url, target_url)
615
cs.set((b"remote", remote), b"url", location)
617
cs.set((b"branch", remote), b"merge", branch_name_to_ref(branch))
619
cs.set((b"branch", remote), b"merge", ref)
621
# TODO(jelmer): Maybe unset rather than setting to HEAD?
622
cs.set((b"branch", remote), b"merge", b'HEAD')
623
self._write_git_config(cs)
625
def break_lock(self):
626
raise NotImplementedError(self.break_lock)
630
if self._lock_mode not in ('r', 'w'):
631
raise ValueError(self._lock_mode)
632
self._lock_count += 1
634
self._lock_mode = 'r'
636
self.repository.lock_read()
637
return lock.LogicalLockResult(self.unlock)
639
def peek_lock_mode(self):
640
return self._lock_mode
643
return (self._lock_mode is not None)
648
def _unlock_ref(self):
652
"""See Branch.unlock()."""
653
if self._lock_count == 0:
654
raise errors.LockNotHeld(self)
656
self._lock_count -= 1
657
if self._lock_count == 0:
658
if self._lock_mode == 'w':
660
self._lock_mode = None
661
self._clear_cached_state()
663
self.repository.unlock()
665
def get_physical_lock_status(self):
668
def last_revision(self):
669
with self.lock_read():
670
# perhaps should escape this ?
671
if self.head is None:
672
return revision.NULL_REVISION
673
return self.lookup_foreign_revision_id(self.head)
675
def _basic_push(self, target, overwrite=False, stop_revision=None,
677
return branch.InterBranch.get(self, target)._basic_push(
678
overwrite, stop_revision, tag_selector=tag_selector)
680
def lookup_foreign_revision_id(self, foreign_revid):
682
return self.repository.lookup_foreign_revision_id(foreign_revid,
686
return self.mapping.revision_id_foreign_to_bzr(foreign_revid)
688
def lookup_bzr_revision_id(self, revid):
689
return self.repository.lookup_bzr_revision_id(
690
revid, mapping=self.mapping)
692
def get_unshelver(self, tree):
693
raise errors.StoringUncommittedNotSupported(self)
695
def _clear_cached_state(self):
696
super(GitBranch, self)._clear_cached_state()
697
self._tag_refs = None
699
def _iter_tag_refs(self, refs):
700
"""Iterate over the tag refs.
702
:param refs: Refs dictionary (name -> git sha1)
703
:return: iterator over (ref_name, tag_name, peeled_sha1, unpeeled_sha1)
705
raise NotImplementedError(self._iter_tag_refs)
707
def get_tag_refs(self):
708
with self.lock_read():
709
if self._tag_refs is None:
710
self._tag_refs = list(self._iter_tag_refs())
711
return self._tag_refs
713
def import_last_revision_info_and_tags(self, source, revno, revid,
715
"""Set the last revision info, importing from another repo if necessary.
717
This is used by the bound branch code to upload a revision to
718
the master branch first before updating the tip of the local branch.
719
Revisions referenced by source's tags are also transferred.
721
:param source: Source branch to optionally fetch from
722
:param revno: Revision number of the new tip
723
:param revid: Revision id of the new tip
724
:param lossy: Whether to discard metadata that can not be
726
:return: Tuple with the new revision number and revision id
727
(should only be different from the arguments when lossy=True)
729
push_result = source.push(
730
self, stop_revision=revid, lossy=lossy, _stop_revno=revno)
731
return (push_result.new_revno, push_result.new_revid)
733
def reconcile(self, thorough=True):
734
"""Make sure the data stored in this branch is consistent."""
735
from ..reconcile import ReconcileResult
737
return ReconcileResult()
740
class LocalGitBranch(GitBranch):
741
"""A local Git branch."""
743
def __init__(self, controldir, repository, ref):
744
super(LocalGitBranch, self).__init__(controldir, repository, ref,
745
LocalGitBranchFormat())
747
def create_checkout(self, to_location, revision_id=None, lightweight=False,
748
accelerator_tree=None, hardlink=False):
749
t = transport.get_transport(to_location)
751
format = self._get_checkout_format(lightweight=lightweight)
752
checkout = format.initialize_on_transport(t)
754
from_branch = checkout.set_branch_reference(target_branch=self)
756
policy = checkout.determine_repository_policy()
757
policy.acquire_repository()
758
checkout_branch = checkout.create_branch()
759
checkout_branch.bind(self)
760
checkout_branch.pull(self, stop_revision=revision_id)
762
return checkout.create_workingtree(
763
revision_id, from_branch=from_branch, hardlink=hardlink)
766
self._ref_lock = self.repository._git.refs.lock_ref(self.ref)
768
def _unlock_ref(self):
769
self._ref_lock.unlock()
771
def break_lock(self):
772
self.repository._git.refs.unlock_ref(self.ref)
774
def _gen_revision_history(self):
775
if self.head is None:
777
last_revid = self.last_revision()
778
graph = self.repository.get_graph()
780
ret = list(graph.iter_lefthand_ancestry(
781
last_revid, (revision.NULL_REVISION, )))
782
except errors.RevisionNotPresent as e:
783
raise errors.GhostRevisionsHaveNoRevno(last_revid, e.revision_id)
789
return self.repository._git.refs[self.ref]
793
def _read_last_revision_info(self):
794
last_revid = self.last_revision()
795
graph = self.repository.get_graph()
797
revno = graph.find_distance_to_null(
798
last_revid, [(revision.NULL_REVISION, 0)])
799
except errors.GhostRevisionsHaveNoRevno:
801
return revno, last_revid
803
def set_last_revision_info(self, revno, revision_id):
804
self.set_last_revision(revision_id)
805
self._last_revision_info_cache = revno, revision_id
807
def set_last_revision(self, revid):
808
if not revid or not isinstance(revid, bytes):
809
raise errors.InvalidRevisionId(revision_id=revid, branch=self)
810
if revid == NULL_REVISION:
813
(newhead, self.mapping) = self.repository.lookup_bzr_revision_id(
815
if self.mapping is None:
817
self._set_head(newhead)
819
def _set_head(self, value):
820
if value == ZERO_SHA:
821
raise ValueError(value)
824
del self.repository._git.refs[self.ref]
826
self.repository._git.refs[self.ref] = self._head
827
self._clear_cached_state()
829
head = property(_get_head, _set_head)
831
def get_push_location(self):
832
"""See Branch.get_push_location."""
833
push_loc = self.get_config_stack().get('push_location')
834
if push_loc is not None:
836
cs = self.repository._git.get_config_stack()
837
return self._get_related_push_branch(cs)
839
def set_push_location(self, location):
840
"""See Branch.set_push_location."""
841
self.get_config().set_user_option('push_location', location,
842
store=config.STORE_LOCATION)
844
def supports_tags(self):
847
def store_uncommitted(self, creator):
848
raise errors.StoringUncommittedNotSupported(self)
850
def _iter_tag_refs(self):
851
"""Iterate over the tag refs.
853
:param refs: Refs dictionary (name -> git sha1)
854
:return: iterator over (ref_name, tag_name, peeled_sha1, unpeeled_sha1)
856
refs = self.repository.controldir.get_refs_container()
857
for ref_name, unpeeled in refs.as_dict().items():
859
tag_name = ref_to_tag_name(ref_name)
860
except (ValueError, UnicodeDecodeError):
862
peeled = refs.get_peeled(ref_name)
865
if not isinstance(tag_name, str):
866
raise TypeError(tag_name)
867
yield (ref_name, tag_name, peeled, unpeeled)
869
def create_memorytree(self):
870
from .memorytree import GitMemoryTree
871
return GitMemoryTree(self, self.repository._git.object_store,
875
def _quick_lookup_revno(local_branch, remote_branch, revid):
876
if not isinstance(revid, bytes):
877
raise TypeError(revid)
878
# Try in source branch first, it'll be faster
879
with local_branch.lock_read():
880
if not _calculate_revnos(local_branch):
883
return local_branch.revision_id_to_revno(revid)
884
except errors.NoSuchRevision:
885
graph = local_branch.repository.get_graph()
887
return graph.find_distance_to_null(
888
revid, [(revision.NULL_REVISION, 0)])
889
except errors.GhostRevisionsHaveNoRevno:
890
if not _calculate_revnos(remote_branch):
892
# FIXME: Check using graph.find_distance_to_null() ?
893
with remote_branch.lock_read():
894
return remote_branch.revision_id_to_revno(revid)
897
class GitBranchPullResult(branch.PullResult):
900
super(GitBranchPullResult, self).__init__()
901
self.new_git_head = None
902
self._old_revno = None
903
self._new_revno = None
905
def report(self, to_file):
907
if self.old_revid == self.new_revid:
908
to_file.write('No revisions to pull.\n')
909
elif self.new_git_head is not None:
910
to_file.write('Now on revision %d (git sha: %s).\n' %
911
(self.new_revno, self.new_git_head))
913
to_file.write('Now on revision %d.\n' % (self.new_revno,))
914
self._show_tag_conficts(to_file)
916
def _lookup_revno(self, revid):
917
return _quick_lookup_revno(self.target_branch, self.source_branch,
920
def _get_old_revno(self):
921
if self._old_revno is not None:
922
return self._old_revno
923
return self._lookup_revno(self.old_revid)
925
def _set_old_revno(self, revno):
926
self._old_revno = revno
928
old_revno = property(_get_old_revno, _set_old_revno)
930
def _get_new_revno(self):
931
if self._new_revno is not None:
932
return self._new_revno
933
return self._lookup_revno(self.new_revid)
935
def _set_new_revno(self, revno):
936
self._new_revno = revno
938
new_revno = property(_get_new_revno, _set_new_revno)
941
class GitBranchPushResult(branch.BranchPushResult):
943
def _lookup_revno(self, revid):
944
return _quick_lookup_revno(self.source_branch, self.target_branch,
949
return self._lookup_revno(self.old_revid)
953
new_original_revno = getattr(self, "new_original_revno", None)
954
if new_original_revno:
955
return new_original_revno
956
if getattr(self, "new_original_revid", None) is not None:
957
return self._lookup_revno(self.new_original_revid)
958
return self._lookup_revno(self.new_revid)
961
class InterFromGitBranch(branch.GenericInterBranch):
962
"""InterBranch implementation that pulls from Git into bzr."""
965
def _get_branch_formats_to_test():
967
default_format = branch.format_registry.get_default()
968
except AttributeError:
969
default_format = branch.BranchFormat._default_format
970
from .remote import RemoteGitBranchFormat
972
(RemoteGitBranchFormat(), default_format),
973
(LocalGitBranchFormat(), default_format)]
976
def _get_interrepo(self, source, target):
977
return _mod_repository.InterRepository.get(
978
source.repository, target.repository)
981
def is_compatible(cls, source, target):
982
if not isinstance(source, GitBranch):
984
if isinstance(target, GitBranch):
985
# InterLocalGitRemoteGitBranch or InterToGitBranch should be used
987
if (getattr(cls._get_interrepo(source, target), "fetch_objects", None)
989
# fetch_objects is necessary for this to work
993
def fetch(self, stop_revision=None, fetch_tags=None, limit=None, lossy=False):
995
stop_revision, fetch_tags=fetch_tags, limit=limit, lossy=lossy)
996
return _mod_repository.FetchResult()
998
def fetch_objects(self, stop_revision, fetch_tags, limit=None, lossy=False, tag_selector=None):
999
interrepo = self._get_interrepo(self.source, self.target)
1000
if fetch_tags is None:
1001
c = self.source.get_config_stack()
1002
fetch_tags = c.get('branch.fetch_tags')
1004
def determine_wants(heads):
1005
if stop_revision is None:
1007
head = heads[self.source.ref]
1009
self._last_revid = revision.NULL_REVISION
1011
self._last_revid = self.source.lookup_foreign_revision_id(
1014
self._last_revid = stop_revision
1015
real = interrepo.get_determine_wants_revids(
1016
[self._last_revid], include_tags=fetch_tags, tag_selector=tag_selector)
1018
pack_hint, head, refs = interrepo.fetch_objects(
1019
determine_wants, self.source.mapping, limit=limit,
1021
if (pack_hint is not None and
1022
self.target.repository._format.pack_compresses):
1023
self.target.repository.pack(hint=pack_hint)
1026
def _update_revisions(self, stop_revision=None, overwrite=False, tag_selector=None):
1027
head, refs = self.fetch_objects(stop_revision, fetch_tags=None, tag_selector=tag_selector)
1029
prev_last_revid = None
1031
prev_last_revid = self.target.last_revision()
1032
self.target.generate_revision_history(
1033
self._last_revid, last_rev=prev_last_revid,
1034
other_branch=self.source)
1037
def update_references(self, revid=None):
1039
revid = self.target.last_revision()
1040
tree = self.target.repository.revision_tree(revid)
1042
with tree.get_file('.gitmodules') as f:
1043
for path, url, section in parse_submodules(
1044
GitConfigFile.from_file(f)):
1045
self.target.set_reference_info(
1046
tree.path2id(decode_git_path(path)), url.decode('utf-8'),
1047
decode_git_path(path))
1048
except errors.NoSuchFile:
1051
def _basic_pull(self, stop_revision, overwrite, run_hooks,
1052
_override_hook_target, _hook_master, tag_selector=None):
1053
if overwrite is True:
1054
overwrite = set(["history", "tags"])
1057
result = GitBranchPullResult()
1058
result.source_branch = self.source
1059
if _override_hook_target is None:
1060
result.target_branch = self.target
1062
result.target_branch = _override_hook_target
1063
with self.target.lock_write(), self.source.lock_read():
1064
# We assume that during 'pull' the target repository is closer than
1066
(result.old_revno, result.old_revid) = \
1067
self.target.last_revision_info()
1068
result.new_git_head, remote_refs = self._update_revisions(
1069
stop_revision, overwrite=("history" in overwrite),
1070
tag_selector=tag_selector)
1071
tags_ret = self.source.tags.merge_to(
1072
self.target.tags, ("tags" in overwrite), ignore_master=True)
1073
if isinstance(tags_ret, tuple):
1074
result.tag_updates, result.tag_conflicts = tags_ret
1076
result.tag_conflicts = tags_ret
1077
(result.new_revno, result.new_revid) = \
1078
self.target.last_revision_info()
1079
self.update_references(revid=result.new_revid)
1081
result.master_branch = _hook_master
1082
result.local_branch = result.target_branch
1084
result.master_branch = result.target_branch
1085
result.local_branch = None
1087
for hook in branch.Branch.hooks['post_pull']:
1091
def pull(self, overwrite=False, stop_revision=None,
1092
possible_transports=None, _hook_master=None, run_hooks=True,
1093
_override_hook_target=None, local=False, tag_selector=None):
1096
:param _hook_master: Private parameter - set the branch to
1097
be supplied as the master to pull hooks.
1098
:param run_hooks: Private parameter - if false, this branch
1099
is being called because it's the master of the primary branch,
1100
so it should not run its hooks.
1101
:param _override_hook_target: Private parameter - set the branch to be
1102
supplied as the target_branch to pull hooks.
1104
# This type of branch can't be bound.
1105
bound_location = self.target.get_bound_location()
1106
if local and not bound_location:
1107
raise errors.LocalRequiresBoundBranch()
1108
source_is_master = False
1109
with contextlib.ExitStack() as es:
1110
es.enter_context(self.source.lock_read())
1112
# bound_location comes from a config file, some care has to be
1113
# taken to relate it to source.user_url
1114
normalized = urlutils.normalize_url(bound_location)
1116
relpath = self.source.user_transport.relpath(normalized)
1117
source_is_master = (relpath == '')
1118
except (errors.PathNotChild, urlutils.InvalidURL):
1119
source_is_master = False
1120
if not local and bound_location and not source_is_master:
1121
# not pulling from master, so we need to update master.
1122
master_branch = self.target.get_master_branch(possible_transports)
1123
es.enter_context(master_branch.lock_write())
1124
# pull from source into master.
1125
master_branch.pull(self.source, overwrite, stop_revision,
1128
master_branch = None
1129
return self._basic_pull(stop_revision, overwrite, run_hooks,
1130
_override_hook_target,
1131
_hook_master=master_branch,
1132
tag_selector=tag_selector)
1134
def _basic_push(self, overwrite, stop_revision, tag_selector=None):
1135
if overwrite is True:
1136
overwrite = set(["history", "tags"])
1139
result = branch.BranchPushResult()
1140
result.source_branch = self.source
1141
result.target_branch = self.target
1142
result.old_revno, result.old_revid = self.target.last_revision_info()
1143
result.new_git_head, remote_refs = self._update_revisions(
1144
stop_revision, overwrite=("history" in overwrite),
1145
tag_selector=tag_selector)
1146
tags_ret = self.source.tags.merge_to(
1147
self.target.tags, "tags" in overwrite, ignore_master=True,
1148
selector=tag_selector)
1149
(result.tag_updates, result.tag_conflicts) = tags_ret
1150
result.new_revno, result.new_revid = self.target.last_revision_info()
1151
self.update_references(revid=result.new_revid)
1155
class InterGitBranch(branch.GenericInterBranch):
1156
"""InterBranch implementation that pulls between Git branches."""
1158
def fetch(self, stop_revision=None, fetch_tags=None, limit=None, lossy=False):
1159
raise NotImplementedError(self.fetch)
1162
class InterLocalGitRemoteGitBranch(InterGitBranch):
1163
"""InterBranch that copies from a local to a remote git branch."""
1166
def _get_branch_formats_to_test():
1167
from .remote import RemoteGitBranchFormat
1169
(LocalGitBranchFormat(), RemoteGitBranchFormat())]
1172
def is_compatible(self, source, target):
1173
from .remote import RemoteGitBranch
1174
return (isinstance(source, LocalGitBranch) and
1175
isinstance(target, RemoteGitBranch))
1177
def _basic_push(self, overwrite, stop_revision, tag_selector=None):
1178
from .remote import parse_git_error
1179
result = GitBranchPushResult()
1180
result.source_branch = self.source
1181
result.target_branch = self.target
1182
if stop_revision is None:
1183
stop_revision = self.source.last_revision()
1185
def get_changed_refs(old_refs):
1186
old_ref = old_refs.get(self.target.ref, None)
1188
result.old_revid = revision.NULL_REVISION
1190
result.old_revid = self.target.lookup_foreign_revision_id(
1192
new_ref = self.source.repository.lookup_bzr_revision_id(
1195
if remote_divergence(
1197
self.source.repository._git.object_store):
1198
raise errors.DivergedBranches(self.source, self.target)
1199
refs = {self.target.ref: new_ref}
1200
result.new_revid = stop_revision
1202
self.source.repository._git.refs.as_dict(b"refs/tags").items()):
1203
if tag_selector and not tag_selector(name):
1205
if sha not in self.source.repository._git:
1206
trace.mutter('Ignoring missing SHA: %s', sha)
1208
refs[tag_name_to_ref(name)] = sha
1210
dw_result = self.target.repository.send_pack(
1212
self.source.repository._git.generate_pack_data)
1213
if dw_result is not None and not isinstance(dw_result, dict):
1214
error = dw_result.ref_status.get(self.target.ref)
1216
raise parse_git_error(self.target.user_url, error)
1217
for ref, error in dw_result.ref_status.items():
1219
trace.warning('unable to open ref %s: %s', ref, error)
1223
class InterGitLocalGitBranch(InterGitBranch):
1224
"""InterBranch that copies from a remote to a local git branch."""
1227
def _get_branch_formats_to_test():
1228
from .remote import RemoteGitBranchFormat
1230
(RemoteGitBranchFormat(), LocalGitBranchFormat()),
1231
(LocalGitBranchFormat(), LocalGitBranchFormat())]
1234
def is_compatible(self, source, target):
1235
return (isinstance(source, GitBranch) and
1236
isinstance(target, LocalGitBranch))
1238
def fetch(self, stop_revision=None, fetch_tags=None, limit=None, lossy=False):
1239
interrepo = _mod_repository.InterRepository.get(
1240
self.source.repository, self.target.repository)
1241
if stop_revision is None:
1242
stop_revision = self.source.last_revision()
1243
if fetch_tags is None:
1244
c = self.source.get_config_stack()
1245
fetch_tags = c.get('branch.fetch_tags')
1246
determine_wants = interrepo.get_determine_wants_revids(
1247
[stop_revision], include_tags=fetch_tags)
1248
interrepo.fetch_objects(determine_wants, limit=limit, lossy=lossy)
1249
return _mod_repository.FetchResult()
1251
def _basic_push(self, overwrite=False, stop_revision=None, tag_selector=None):
1252
if overwrite is True:
1253
overwrite = set(["history", "tags"])
1256
result = GitBranchPushResult()
1257
result.source_branch = self.source
1258
result.target_branch = self.target
1259
result.old_revid = self.target.last_revision()
1260
refs, stop_revision = self.update_refs(stop_revision)
1261
self.target.generate_revision_history(
1263
(result.old_revid if ("history" not in overwrite) else None),
1264
other_branch=self.source)
1265
tags_ret = self.source.tags.merge_to(
1267
overwrite=("tags" in overwrite),
1268
selector=tag_selector)
1269
if isinstance(tags_ret, tuple):
1270
(result.tag_updates, result.tag_conflicts) = tags_ret
1272
result.tag_conflicts = tags_ret
1273
result.new_revid = self.target.last_revision()
1276
def update_refs(self, stop_revision=None):
1277
interrepo = _mod_repository.InterRepository.get(
1278
self.source.repository, self.target.repository)
1279
c = self.source.get_config_stack()
1280
fetch_tags = c.get('branch.fetch_tags')
1282
if stop_revision is None:
1283
result = interrepo.fetch(branches=[self.source.ref], include_tags=fetch_tags)
1285
head = result.refs[self.source.ref]
1287
stop_revision = revision.NULL_REVISION
1289
stop_revision = self.target.lookup_foreign_revision_id(head)
1291
result = interrepo.fetch(
1292
revision_id=stop_revision, include_tags=fetch_tags)
1293
return result.refs, stop_revision
1295
def pull(self, stop_revision=None, overwrite=False,
1296
possible_transports=None, run_hooks=True, local=False,
1298
# This type of branch can't be bound.
1300
raise errors.LocalRequiresBoundBranch()
1301
if overwrite is True:
1302
overwrite = set(["history", "tags"])
1306
result = GitPullResult()
1307
result.source_branch = self.source
1308
result.target_branch = self.target
1309
with self.target.lock_write(), self.source.lock_read():
1310
result.old_revid = self.target.last_revision()
1311
refs, stop_revision = self.update_refs(stop_revision)
1312
self.target.generate_revision_history(
1314
(result.old_revid if ("history" not in overwrite) else None),
1315
other_branch=self.source)
1316
tags_ret = self.source.tags.merge_to(
1317
self.target.tags, overwrite=("tags" in overwrite),
1318
selector=tag_selector)
1319
if isinstance(tags_ret, tuple):
1320
(result.tag_updates, result.tag_conflicts) = tags_ret
1322
result.tag_conflicts = tags_ret
1323
result.new_revid = self.target.last_revision()
1324
result.local_branch = None
1325
result.master_branch = result.target_branch
1327
for hook in branch.Branch.hooks['post_pull']:
1332
class InterToGitBranch(branch.GenericInterBranch):
1333
"""InterBranch implementation that pulls into a Git branch."""
1335
def __init__(self, source, target):
1336
super(InterToGitBranch, self).__init__(source, target)
1337
self.interrepo = _mod_repository.InterRepository.get(source.repository,
1341
def _get_branch_formats_to_test():
1343
default_format = branch.format_registry.get_default()
1344
except AttributeError:
1345
default_format = branch.BranchFormat._default_format
1346
from .remote import RemoteGitBranchFormat
1348
(default_format, LocalGitBranchFormat()),
1349
(default_format, RemoteGitBranchFormat())]
1352
def is_compatible(self, source, target):
1353
return (not isinstance(source, GitBranch) and
1354
isinstance(target, GitBranch))
1356
def _get_new_refs(self, stop_revision=None, fetch_tags=None,
1358
if not self.source.is_locked():
1359
raise errors.ObjectNotLocked(self.source)
1360
if stop_revision is None:
1361
(stop_revno, stop_revision) = self.source.last_revision_info()
1362
elif stop_revno is None:
1364
stop_revno = self.source.revision_id_to_revno(stop_revision)
1365
except errors.NoSuchRevision:
1367
if not isinstance(stop_revision, bytes):
1368
raise TypeError(stop_revision)
1369
main_ref = self.target.ref
1370
refs = {main_ref: (None, stop_revision)}
1371
if fetch_tags is None:
1372
c = self.source.get_config_stack()
1373
fetch_tags = c.get('branch.fetch_tags')
1374
for name, revid in self.source.tags.get_tag_dict().items():
1375
if self.source.repository.has_revision(revid):
1376
ref = tag_name_to_ref(name)
1377
if not check_ref_format(ref):
1378
warning("skipping tag with invalid characters %s (%s)",
1382
# FIXME: Skip tags that are not in the ancestry
1383
refs[ref] = (None, revid)
1384
return refs, main_ref, (stop_revno, stop_revision)
1386
def _update_refs(self, result, old_refs, new_refs, overwrite, tag_selector):
1387
mutter("updating refs. old refs: %r, new refs: %r",
1389
result.tag_updates = {}
1390
result.tag_conflicts = []
1393
def ref_equals(refs, ref, git_sha, revid):
1398
if (value[0] is not None and
1399
git_sha is not None and
1400
value[0] == git_sha):
1402
if (value[1] is not None and
1403
revid is not None and
1406
# FIXME: If one side only has the git sha available and the other
1407
# only has the bzr revid, then this will cause us to show a tag as
1408
# updated that hasn't actually been updated.
1410
# FIXME: Check for diverged branches
1411
for ref, (git_sha, revid) in new_refs.items():
1412
if ref_equals(ret, ref, git_sha, revid):
1413
# Already up to date
1415
git_sha = old_refs[ref][0]
1417
revid = old_refs[ref][1]
1418
ret[ref] = new_refs[ref] = (git_sha, revid)
1419
elif ref not in ret or overwrite:
1421
tag_name = ref_to_tag_name(ref)
1425
if tag_selector and not tag_selector(tag_name):
1427
result.tag_updates[tag_name] = revid
1428
ret[ref] = (git_sha, revid)
1430
# FIXME: Check diverged
1434
name = ref_to_tag_name(ref)
1438
result.tag_conflicts.append(
1439
(name, revid, ret[name][1]))
1441
ret[ref] = (git_sha, revid)
1444
def fetch(self, stop_revision=None, fetch_tags=None, lossy=False,
1446
if stop_revision is None:
1447
stop_revision = self.source.last_revision()
1450
for k, v in self.source.tags.get_tag_dict().items():
1451
ret.append((None, v))
1452
ret.append((None, stop_revision))
1454
revidmap = self.interrepo.fetch_objects(ret, lossy=lossy, limit=limit)
1455
except NoPushSupport:
1456
raise errors.NoRoundtrippingSupport(self.source, self.target)
1457
return _mod_repository.FetchResult(revidmap={
1458
old_revid: new_revid
1459
for (old_revid, (new_sha, new_revid)) in revidmap.items()})
1461
def pull(self, overwrite=False, stop_revision=None, local=False,
1462
possible_transports=None, run_hooks=True, _stop_revno=None,
1464
result = GitBranchPullResult()
1465
result.source_branch = self.source
1466
result.target_branch = self.target
1467
with self.source.lock_read(), self.target.lock_write():
1468
new_refs, main_ref, stop_revinfo = self._get_new_refs(
1469
stop_revision, stop_revno=_stop_revno)
1471
def update_refs(old_refs):
1472
return self._update_refs(result, old_refs, new_refs, overwrite, tag_selector)
1474
result.revidmap, old_refs, new_refs = (
1475
self.interrepo.fetch_refs(update_refs, lossy=False))
1476
except NoPushSupport:
1477
raise errors.NoRoundtrippingSupport(self.source, self.target)
1478
(old_sha1, result.old_revid) = old_refs.get(
1479
main_ref, (ZERO_SHA, NULL_REVISION))
1480
if result.old_revid is None:
1481
result.old_revid = self.target.lookup_foreign_revision_id(
1483
result.new_revid = new_refs[main_ref][1]
1484
result.local_branch = None
1485
result.master_branch = self.target
1487
for hook in branch.Branch.hooks['post_pull']:
1491
def push(self, overwrite=False, stop_revision=None, lossy=False,
1492
_override_hook_source_branch=None, _stop_revno=None,
1494
result = GitBranchPushResult()
1495
result.source_branch = self.source
1496
result.target_branch = self.target
1497
result.local_branch = None
1498
result.master_branch = result.target_branch
1499
with self.source.lock_read(), self.target.lock_write():
1500
new_refs, main_ref, stop_revinfo = self._get_new_refs(
1501
stop_revision, stop_revno=_stop_revno)
1503
def update_refs(old_refs):
1504
return self._update_refs(result, old_refs, new_refs, overwrite, tag_selector)
1506
result.revidmap, old_refs, new_refs = (
1507
self.interrepo.fetch_refs(
1508
update_refs, lossy=lossy, overwrite=overwrite))
1509
except NoPushSupport:
1510
raise errors.NoRoundtrippingSupport(self.source, self.target)
1511
(old_sha1, result.old_revid) = old_refs.get(
1512
main_ref, (ZERO_SHA, NULL_REVISION))
1513
if lossy or result.old_revid is None:
1514
result.old_revid = self.target.lookup_foreign_revision_id(
1516
result.new_revid = new_refs[main_ref][1]
1517
(result.new_original_revno,
1518
result.new_original_revid) = stop_revinfo
1519
for hook in branch.Branch.hooks['post_push']:
1524
branch.InterBranch.register_optimiser(InterGitLocalGitBranch)
1525
branch.InterBranch.register_optimiser(InterFromGitBranch)
1526
branch.InterBranch.register_optimiser(InterToGitBranch)
1527
branch.InterBranch.register_optimiser(InterLocalGitRemoteGitBranch)
added
removed
breezy/git/branch.py
