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 (
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()
136
def get_changed_refs(old_refs):
138
for ref_name, tag_name, peeled, unpeeled in (
139
source_tag_refs.iteritems()):
140
if selector and not selector(tag_name):
142
if old_refs.get(ref_name) == unpeeled:
144
elif overwrite or ref_name not in old_refs:
145
ret[ref_name] = unpeeled
146
updates[tag_name] = self.target.branch.repository.lookup_foreign_revision_id(
148
self.target.branch._tag_refs = None
152
self.repository.lookup_foreign_revision_id(peeled),
153
self.target.branch.repository.lookup_foreign_revision_id(
154
old_refs[ref_name])))
156
self.target.branch.repository.controldir.send_pack(
157
get_changed_refs, lambda have, want: [])
158
return updates, set(conflicts)
161
class InterTagsFromGitToLocalGit(InterTags):
164
def is_compatible(klass, source, target):
165
if not isinstance(source, GitTags):
167
if not isinstance(target, GitTags):
169
if getattr(target.branch.repository, "_git", None) is None:
173
def merge(self, overwrite=False, ignore_master=False, selector=None):
174
if self.source.branch.repository.has_same_location(self.target.branch.repository):
179
source_tag_refs = self.source.branch.get_tag_refs()
181
target_repo = self.target.branch.repository
183
for ref_name, tag_name, peeled, unpeeled in source_tag_refs:
184
if selector and not selector(tag_name):
186
if target_repo._git.refs.get(ref_name) == unpeeled:
188
elif overwrite or ref_name not in target_repo._git.refs:
190
updates[tag_name] = (
191
target_repo.lookup_foreign_revision_id(peeled))
193
trace.warning('%s does not point to a valid object',
196
except NotCommitError:
197
trace.warning('%s points to a non-commit object',
200
target_repo._git.refs[ref_name] = unpeeled or peeled
201
self.target.branch._tag_refs = None
204
source_revid = self.source.branch.repository.lookup_foreign_revision_id(
206
target_revid = target_repo.lookup_foreign_revision_id(
207
target_repo._git.refs[ref_name])
209
trace.warning('%s does not point to a valid object',
212
except NotCommitError:
213
trace.warning('%s points to a non-commit object',
216
conflicts.append((tag_name, source_revid, target_revid))
217
return updates, set(conflicts)
220
class InterTagsFromGitToNonGit(InterTags):
223
def is_compatible(klass, source, target):
224
if not isinstance(source, GitTags):
226
if isinstance(target, GitTags):
230
def merge(self, overwrite=False, ignore_master=False, selector=None):
231
"""See Tags.merge_to."""
232
source_tag_refs = self.source.branch.get_tag_refs()
236
master = self.target.branch.get_master_branch()
237
with contextlib.ExitStack() as es:
238
if master is not None:
239
es.enter_context(master.lock_write())
240
updates, conflicts = self._merge_to(
241
self.target, source_tag_refs, overwrite=overwrite,
243
if master is not None:
244
extra_updates, extra_conflicts = self._merge_to(
245
master.tags, overwrite=overwrite,
246
source_tag_refs=source_tag_refs,
247
ignore_master=ignore_master, selector=selector)
248
updates.update(extra_updates)
249
conflicts.update(extra_conflicts)
250
return updates, conflicts
252
def _merge_to(self, to_tags, source_tag_refs, overwrite=False,
254
unpeeled_map = defaultdict(set)
257
result = dict(to_tags.get_tag_dict())
258
for ref_name, tag_name, peeled, unpeeled in source_tag_refs:
259
if selector and not selector(tag_name):
261
if unpeeled is not None:
262
unpeeled_map[peeled].add(unpeeled)
264
bzr_revid = self.source.branch.lookup_foreign_revision_id(peeled)
265
except NotCommitError:
267
if result.get(tag_name) == bzr_revid:
269
elif tag_name not in result or overwrite:
270
result[tag_name] = bzr_revid
271
updates[tag_name] = bzr_revid
273
conflicts.append((tag_name, bzr_revid, result[tag_name]))
274
to_tags._set_tag_dict(result)
275
if len(unpeeled_map) > 0:
276
map_file = UnpeelMap.from_repository(to_tags.branch.repository)
277
map_file.update(unpeeled_map)
278
map_file.save_in_repository(to_tags.branch.repository)
279
return updates, set(conflicts)
282
InterTags.register_optimiser(InterTagsFromGitToRemoteGit)
283
InterTags.register_optimiser(InterTagsFromGitToLocalGit)
284
InterTags.register_optimiser(InterTagsFromGitToNonGit)
288
"""Ref-based tag dictionary."""
290
def __init__(self, branch):
292
self.repository = branch.repository
294
def get_tag_dict(self):
296
for (ref_name, tag_name, peeled, unpeeled) in (
297
self.branch.get_tag_refs()):
299
bzr_revid = self.branch.lookup_foreign_revision_id(peeled)
300
except NotCommitError:
303
ret[tag_name] = bzr_revid
306
def lookup_tag(self, tag_name):
307
"""Return the referent string of a tag"""
308
# TODO(jelmer): Replace with something more efficient for local tags.
309
td = self.get_tag_dict()
313
raise errors.NoSuchTag(tag_name)
316
class LocalGitTagDict(GitTags):
317
"""Dictionary with tags in a local repository."""
319
def __init__(self, branch):
320
super(LocalGitTagDict, self).__init__(branch)
321
self.refs = self.repository.controldir._git.refs
323
def _set_tag_dict(self, to_dict):
324
extra = set(self.refs.allkeys())
325
for k, revid in to_dict.items():
326
name = tag_name_to_ref(k)
330
self.set_tag(k, revid)
331
except errors.GhostTagsNotSupported:
335
del self.repository._git[name]
337
def set_tag(self, name, revid):
339
git_sha, mapping = self.branch.lookup_bzr_revision_id(revid)
340
except errors.NoSuchRevision:
341
raise errors.GhostTagsNotSupported(self)
342
self.refs[tag_name_to_ref(name)] = git_sha
343
self.branch._tag_refs = None
345
def delete_tag(self, name):
346
ref = tag_name_to_ref(name)
347
if ref not in self.refs:
348
raise errors.NoSuchTag(name)
350
self.branch._tag_refs = None
353
class GitBranchFormat(branch.BranchFormat):
355
def network_name(self):
358
def supports_tags(self):
361
def supports_leaving_lock(self):
364
def supports_tags_referencing_ghosts(self):
367
def tags_are_versioned(self):
370
def get_foreign_tests_branch_factory(self):
371
from .tests.test_branch import ForeignTestsBranchFactory
372
return ForeignTestsBranchFactory()
374
def make_tags(self, branch):
377
except AttributeError:
379
if getattr(branch.repository, "_git", None) is None:
380
from .remote import RemoteGitTagDict
381
return RemoteGitTagDict(branch)
383
return LocalGitTagDict(branch)
385
def initialize(self, a_controldir, name=None, repository=None,
386
append_revisions_only=None):
387
raise NotImplementedError(self.initialize)
389
def get_reference(self, controldir, name=None):
390
return controldir.get_branch_reference(name=name)
392
def set_reference(self, controldir, name, target):
393
return controldir.set_branch_reference(target, name)
395
def stores_revno(self):
396
"""True if this branch format store revision numbers."""
399
supports_reference_locations = False
402
class LocalGitBranchFormat(GitBranchFormat):
404
def get_format_description(self):
405
return 'Local Git Branch'
408
def _matchingcontroldir(self):
409
from .dir import LocalGitControlDirFormat
410
return LocalGitControlDirFormat()
412
def initialize(self, a_controldir, name=None, repository=None,
413
append_revisions_only=None):
414
from .dir import LocalGitDir
415
if not isinstance(a_controldir, LocalGitDir):
416
raise errors.IncompatibleFormat(self, a_controldir._format)
417
return a_controldir.create_branch(
418
repository=repository, name=name,
419
append_revisions_only=append_revisions_only)
422
class GitBranch(ForeignBranch):
423
"""An adapter to git repositories for bzr Branch objects."""
426
def control_transport(self):
427
return self._control_transport
430
def user_transport(self):
431
return self._user_transport
433
def __init__(self, controldir, repository, ref, format):
434
self.repository = repository
435
self._format = format
436
self.controldir = controldir
437
self._lock_mode = None
439
super(GitBranch, self).__init__(repository.get_mapping())
442
self._user_transport = controldir.user_transport.clone('.')
443
self._control_transport = controldir.control_transport.clone('.')
444
self._tag_refs = None
447
self.name = ref_to_branch_name(ref)
450
if self.ref is not None:
451
params = {"ref": urlutils.escape(self.ref)}
454
params = {"branch": urlutils.escape(self.name)}
455
for k, v in params.items():
456
self._user_transport.set_segment_parameter(k, v)
457
self._control_transport.set_segment_parameter(k, v)
458
self.base = controldir.user_transport.base
460
def _get_checkout_format(self, lightweight=False):
461
"""Return the most suitable metadir for a checkout of this branch.
462
Weaves are used if this branch's repository uses weaves.
465
return controldir.format_registry.make_controldir("git")
467
return controldir.format_registry.make_controldir("default")
469
def get_child_submit_format(self):
470
"""Return the preferred format of submissions to this branch."""
471
ret = self.get_config_stack().get("child_submit_format")
476
def get_config(self):
477
return GitBranchConfig(self)
479
def get_config_stack(self):
480
return GitBranchStack(self)
482
def _get_nick(self, local=False, possible_master_transports=None):
483
"""Find the nick name for this branch.
487
if getattr(self.repository, '_git', None):
488
cs = self.repository._git.get_config_stack()
490
return cs.get((b"branch", self.name.encode('utf-8')),
491
b"nick").decode("utf-8")
494
return self.name or u"HEAD"
496
def _set_nick(self, nick):
497
cf = self.repository._git.get_config()
498
cf.set((b"branch", self.name.encode('utf-8')),
499
b"nick", nick.encode("utf-8"))
502
self.repository._git._put_named_file('config', f.getvalue())
504
nick = property(_get_nick, _set_nick)
507
return "<%s(%r, %r)>" % (self.__class__.__name__, self.repository.base,
510
def generate_revision_history(self, revid, last_rev=None,
512
if last_rev is not None:
513
graph = self.repository.get_graph()
514
if not graph.is_ancestor(last_rev, revid):
515
# our previous tip is not merged into stop_revision
516
raise errors.DivergedBranches(self, other_branch)
518
self.set_last_revision(revid)
520
def lock_write(self, token=None):
521
if token is not None:
522
raise errors.TokenLockingNotSupported(self)
524
if self._lock_mode == 'r':
525
raise errors.ReadOnlyError(self)
526
self._lock_count += 1
529
self._lock_mode = 'w'
531
self.repository.lock_write()
532
return lock.LogicalLockResult(self.unlock)
534
def leave_lock_in_place(self):
535
raise NotImplementedError(self.leave_lock_in_place)
537
def dont_leave_lock_in_place(self):
538
raise NotImplementedError(self.dont_leave_lock_in_place)
540
def get_stacked_on_url(self):
541
# Git doesn't do stacking (yet...)
542
raise branch.UnstackableBranchFormat(self._format, self.base)
544
def _get_push_origin(self, cs):
545
"""Get the name for the push origin.
547
The exact behaviour is documented in the git-config(1) manpage.
550
return cs.get((b'branch', self.name.encode('utf-8')), b'pushRemote')
553
return cs.get((b'branch', ), b'remote')
556
return cs.get((b'branch', self.name.encode('utf-8')), b'remote')
560
def _get_origin(self, cs):
562
return cs.get((b'branch', self.name.encode('utf-8')), b'remote')
566
def _get_related_push_branch(self, cs):
567
remote = self._get_push_origin(cs)
569
location = cs.get((b"remote", remote), b"url")
573
return git_url_to_bzr_url(location.decode('utf-8'), ref=self.ref)
575
def _get_related_merge_branch(self, cs):
576
remote = self._get_origin(cs)
578
location = cs.get((b"remote", remote), b"url")
583
ref = cs.get((b"branch", remote), b"merge")
587
return git_url_to_bzr_url(location.decode('utf-8'), ref=ref)
589
def _get_parent_location(self):
590
"""See Branch.get_parent()."""
591
cs = self.repository._git.get_config_stack()
592
return self._get_related_merge_branch(cs)
594
def _write_git_config(self, cs):
597
self.repository._git._put_named_file('config', f.getvalue())
599
def set_parent(self, location):
600
cs = self.repository._git.get_config()
601
remote = self._get_origin(cs)
602
this_url = urlutils.strip_segment_parameters(self.user_url)
603
target_url, branch, ref = bzr_url_to_git_url(location)
604
location = urlutils.relative_url(this_url, target_url)
605
cs.set((b"remote", remote), b"url", location)
607
cs.set((b"branch", remote), b"merge", branch_name_to_ref(branch))
609
cs.set((b"branch", remote), b"merge", ref)
611
# TODO(jelmer): Maybe unset rather than setting to HEAD?
612
cs.set((b"branch", remote), b"merge", b'HEAD')
613
self._write_git_config(cs)
615
def break_lock(self):
616
raise NotImplementedError(self.break_lock)
620
if self._lock_mode not in ('r', 'w'):
621
raise ValueError(self._lock_mode)
622
self._lock_count += 1
624
self._lock_mode = 'r'
626
self.repository.lock_read()
627
return lock.LogicalLockResult(self.unlock)
629
def peek_lock_mode(self):
630
return self._lock_mode
633
return (self._lock_mode is not None)
638
def _unlock_ref(self):
642
"""See Branch.unlock()."""
643
if self._lock_count == 0:
644
raise errors.LockNotHeld(self)
646
self._lock_count -= 1
647
if self._lock_count == 0:
648
if self._lock_mode == 'w':
650
self._lock_mode = None
651
self._clear_cached_state()
653
self.repository.unlock()
655
def get_physical_lock_status(self):
658
def last_revision(self):
659
with self.lock_read():
660
# perhaps should escape this ?
661
if self.head is None:
662
return revision.NULL_REVISION
663
return self.lookup_foreign_revision_id(self.head)
665
def _basic_push(self, target, overwrite=False, stop_revision=None,
667
return branch.InterBranch.get(self, target)._basic_push(
668
overwrite, stop_revision, tag_selector=tag_selector)
670
def lookup_foreign_revision_id(self, foreign_revid):
672
return self.repository.lookup_foreign_revision_id(foreign_revid,
676
return self.mapping.revision_id_foreign_to_bzr(foreign_revid)
678
def lookup_bzr_revision_id(self, revid):
679
return self.repository.lookup_bzr_revision_id(
680
revid, mapping=self.mapping)
682
def get_unshelver(self, tree):
683
raise errors.StoringUncommittedNotSupported(self)
685
def _clear_cached_state(self):
686
super(GitBranch, self)._clear_cached_state()
687
self._tag_refs = None
689
def _iter_tag_refs(self, refs):
690
"""Iterate over the tag refs.
692
:param refs: Refs dictionary (name -> git sha1)
693
:return: iterator over (ref_name, tag_name, peeled_sha1, unpeeled_sha1)
695
raise NotImplementedError(self._iter_tag_refs)
697
def get_tag_refs(self):
698
with self.lock_read():
699
if self._tag_refs is None:
700
self._tag_refs = list(self._iter_tag_refs())
701
return self._tag_refs
703
def import_last_revision_info_and_tags(self, source, revno, revid,
705
"""Set the last revision info, importing from another repo if necessary.
707
This is used by the bound branch code to upload a revision to
708
the master branch first before updating the tip of the local branch.
709
Revisions referenced by source's tags are also transferred.
711
:param source: Source branch to optionally fetch from
712
:param revno: Revision number of the new tip
713
:param revid: Revision id of the new tip
714
:param lossy: Whether to discard metadata that can not be
716
:return: Tuple with the new revision number and revision id
717
(should only be different from the arguments when lossy=True)
719
push_result = source.push(
720
self, stop_revision=revid, lossy=lossy, _stop_revno=revno)
721
return (push_result.new_revno, push_result.new_revid)
723
def reconcile(self, thorough=True):
724
"""Make sure the data stored in this branch is consistent."""
725
from ..reconcile import ReconcileResult
727
return ReconcileResult()
730
class LocalGitBranch(GitBranch):
731
"""A local Git branch."""
733
def __init__(self, controldir, repository, ref):
734
super(LocalGitBranch, self).__init__(controldir, repository, ref,
735
LocalGitBranchFormat())
737
def create_checkout(self, to_location, revision_id=None, lightweight=False,
738
accelerator_tree=None, hardlink=False):
739
t = transport.get_transport(to_location)
741
format = self._get_checkout_format(lightweight=lightweight)
742
checkout = format.initialize_on_transport(t)
744
from_branch = checkout.set_branch_reference(target_branch=self)
746
policy = checkout.determine_repository_policy()
747
policy.acquire_repository()
748
checkout_branch = checkout.create_branch()
749
checkout_branch.bind(self)
750
checkout_branch.pull(self, stop_revision=revision_id)
752
return checkout.create_workingtree(
753
revision_id, from_branch=from_branch, hardlink=hardlink)
756
self._ref_lock = self.repository._git.refs.lock_ref(self.ref)
758
def _unlock_ref(self):
759
self._ref_lock.unlock()
761
def break_lock(self):
762
self.repository._git.refs.unlock_ref(self.ref)
764
def _gen_revision_history(self):
765
if self.head is None:
767
last_revid = self.last_revision()
768
graph = self.repository.get_graph()
770
ret = list(graph.iter_lefthand_ancestry(
771
last_revid, (revision.NULL_REVISION, )))
772
except errors.RevisionNotPresent as e:
773
raise errors.GhostRevisionsHaveNoRevno(last_revid, e.revision_id)
779
return self.repository._git.refs[self.ref]
783
def _read_last_revision_info(self):
784
last_revid = self.last_revision()
785
graph = self.repository.get_graph()
787
revno = graph.find_distance_to_null(
788
last_revid, [(revision.NULL_REVISION, 0)])
789
except errors.GhostRevisionsHaveNoRevno:
791
return revno, last_revid
793
def set_last_revision_info(self, revno, revision_id):
794
self.set_last_revision(revision_id)
795
self._last_revision_info_cache = revno, revision_id
797
def set_last_revision(self, revid):
798
if not revid or not isinstance(revid, bytes):
799
raise errors.InvalidRevisionId(revision_id=revid, branch=self)
800
if revid == NULL_REVISION:
803
(newhead, self.mapping) = self.repository.lookup_bzr_revision_id(
805
if self.mapping is None:
807
self._set_head(newhead)
809
def _set_head(self, value):
810
if value == ZERO_SHA:
811
raise ValueError(value)
814
del self.repository._git.refs[self.ref]
816
self.repository._git.refs[self.ref] = self._head
817
self._clear_cached_state()
819
head = property(_get_head, _set_head)
821
def get_push_location(self):
822
"""See Branch.get_push_location."""
823
push_loc = self.get_config_stack().get('push_location')
824
if push_loc is not None:
826
cs = self.repository._git.get_config_stack()
827
return self._get_related_push_branch(cs)
829
def set_push_location(self, location):
830
"""See Branch.set_push_location."""
831
self.get_config().set_user_option('push_location', location,
832
store=config.STORE_LOCATION)
834
def supports_tags(self):
837
def store_uncommitted(self, creator):
838
raise errors.StoringUncommittedNotSupported(self)
840
def _iter_tag_refs(self):
841
"""Iterate over the tag refs.
843
:param refs: Refs dictionary (name -> git sha1)
844
:return: iterator over (ref_name, tag_name, peeled_sha1, unpeeled_sha1)
846
refs = self.repository.controldir.get_refs_container()
847
for ref_name, unpeeled in refs.as_dict().items():
849
tag_name = ref_to_tag_name(ref_name)
850
except (ValueError, UnicodeDecodeError):
852
peeled = refs.get_peeled(ref_name)
855
if not isinstance(tag_name, str):
856
raise TypeError(tag_name)
857
yield (ref_name, tag_name, peeled, unpeeled)
859
def create_memorytree(self):
860
from .memorytree import GitMemoryTree
861
return GitMemoryTree(self, self.repository._git.object_store,
865
def _quick_lookup_revno(local_branch, remote_branch, revid):
866
if not isinstance(revid, bytes):
867
raise TypeError(revid)
868
# Try in source branch first, it'll be faster
869
with local_branch.lock_read():
870
if not _calculate_revnos(local_branch):
873
return local_branch.revision_id_to_revno(revid)
874
except errors.NoSuchRevision:
875
graph = local_branch.repository.get_graph()
877
return graph.find_distance_to_null(
878
revid, [(revision.NULL_REVISION, 0)])
879
except errors.GhostRevisionsHaveNoRevno:
880
if not _calculate_revnos(remote_branch):
882
# FIXME: Check using graph.find_distance_to_null() ?
883
with remote_branch.lock_read():
884
return remote_branch.revision_id_to_revno(revid)
887
class GitBranchPullResult(branch.PullResult):
890
super(GitBranchPullResult, self).__init__()
891
self.new_git_head = None
892
self._old_revno = None
893
self._new_revno = None
895
def report(self, to_file):
897
if self.old_revid == self.new_revid:
898
to_file.write('No revisions to pull.\n')
899
elif self.new_git_head is not None:
900
to_file.write('Now on revision %d (git sha: %s).\n' %
901
(self.new_revno, self.new_git_head))
903
to_file.write('Now on revision %d.\n' % (self.new_revno,))
904
self._show_tag_conficts(to_file)
906
def _lookup_revno(self, revid):
907
return _quick_lookup_revno(self.target_branch, self.source_branch,
910
def _get_old_revno(self):
911
if self._old_revno is not None:
912
return self._old_revno
913
return self._lookup_revno(self.old_revid)
915
def _set_old_revno(self, revno):
916
self._old_revno = revno
918
old_revno = property(_get_old_revno, _set_old_revno)
920
def _get_new_revno(self):
921
if self._new_revno is not None:
922
return self._new_revno
923
return self._lookup_revno(self.new_revid)
925
def _set_new_revno(self, revno):
926
self._new_revno = revno
928
new_revno = property(_get_new_revno, _set_new_revno)
931
class GitBranchPushResult(branch.BranchPushResult):
933
def _lookup_revno(self, revid):
934
return _quick_lookup_revno(self.source_branch, self.target_branch,
939
return self._lookup_revno(self.old_revid)
943
new_original_revno = getattr(self, "new_original_revno", None)
944
if new_original_revno:
945
return new_original_revno
946
if getattr(self, "new_original_revid", None) is not None:
947
return self._lookup_revno(self.new_original_revid)
948
return self._lookup_revno(self.new_revid)
951
class InterFromGitBranch(branch.GenericInterBranch):
952
"""InterBranch implementation that pulls from Git into bzr."""
955
def _get_branch_formats_to_test():
957
default_format = branch.format_registry.get_default()
958
except AttributeError:
959
default_format = branch.BranchFormat._default_format
960
from .remote import RemoteGitBranchFormat
962
(RemoteGitBranchFormat(), default_format),
963
(LocalGitBranchFormat(), default_format)]
966
def _get_interrepo(self, source, target):
967
return _mod_repository.InterRepository.get(
968
source.repository, target.repository)
971
def is_compatible(cls, source, target):
972
if not isinstance(source, GitBranch):
974
if isinstance(target, GitBranch):
975
# InterLocalGitRemoteGitBranch or InterToGitBranch should be used
977
if (getattr(cls._get_interrepo(source, target), "fetch_objects", None)
979
# fetch_objects is necessary for this to work
983
def fetch(self, stop_revision=None, fetch_tags=None, limit=None, lossy=False):
985
stop_revision, fetch_tags=fetch_tags, limit=limit, lossy=lossy)
986
return _mod_repository.FetchResult()
988
def fetch_objects(self, stop_revision, fetch_tags, limit=None, lossy=False, tag_selector=None):
989
interrepo = self._get_interrepo(self.source, self.target)
990
if fetch_tags is None:
991
c = self.source.get_config_stack()
992
fetch_tags = c.get('branch.fetch_tags')
994
def determine_wants(heads):
995
if stop_revision is None:
997
head = heads[self.source.ref]
999
self._last_revid = revision.NULL_REVISION
1001
self._last_revid = self.source.lookup_foreign_revision_id(
1004
self._last_revid = stop_revision
1005
real = interrepo.get_determine_wants_revids(
1006
[self._last_revid], include_tags=fetch_tags, tag_selector=tag_selector)
1008
pack_hint, head, refs = interrepo.fetch_objects(
1009
determine_wants, self.source.mapping, limit=limit,
1011
if (pack_hint is not None and
1012
self.target.repository._format.pack_compresses):
1013
self.target.repository.pack(hint=pack_hint)
1016
def _update_revisions(self, stop_revision=None, overwrite=False, tag_selector=None):
1017
head, refs = self.fetch_objects(stop_revision, fetch_tags=None, tag_selector=tag_selector)
1019
prev_last_revid = None
1021
prev_last_revid = self.target.last_revision()
1022
self.target.generate_revision_history(
1023
self._last_revid, last_rev=prev_last_revid,
1024
other_branch=self.source)
1027
def update_references(self, revid=None):
1029
revid = self.target.last_revision()
1030
tree = self.target.repository.revision_tree(revid)
1032
with tree.get_file('.gitmodules') as f:
1033
for path, url, section in parse_submodules(
1034
GitConfigFile.from_file(f)):
1035
self.target.set_reference_info(
1036
tree.path2id(path.decode('utf-8')), url.decode('utf-8'),
1037
path.decode('utf-8'))
1038
except errors.NoSuchFile:
1041
def _basic_pull(self, stop_revision, overwrite, run_hooks,
1042
_override_hook_target, _hook_master, tag_selector=None):
1043
if overwrite is True:
1044
overwrite = set(["history", "tags"])
1047
result = GitBranchPullResult()
1048
result.source_branch = self.source
1049
if _override_hook_target is None:
1050
result.target_branch = self.target
1052
result.target_branch = _override_hook_target
1053
with self.target.lock_write(), self.source.lock_read():
1054
# We assume that during 'pull' the target repository is closer than
1056
(result.old_revno, result.old_revid) = \
1057
self.target.last_revision_info()
1058
result.new_git_head, remote_refs = self._update_revisions(
1059
stop_revision, overwrite=("history" in overwrite),
1060
tag_selector=tag_selector)
1061
tags_ret = self.source.tags.merge_to(
1062
self.target.tags, ("tags" in overwrite), ignore_master=True)
1063
if isinstance(tags_ret, tuple):
1064
result.tag_updates, result.tag_conflicts = tags_ret
1066
result.tag_conflicts = tags_ret
1067
(result.new_revno, result.new_revid) = \
1068
self.target.last_revision_info()
1069
self.update_references(revid=result.new_revid)
1071
result.master_branch = _hook_master
1072
result.local_branch = result.target_branch
1074
result.master_branch = result.target_branch
1075
result.local_branch = None
1077
for hook in branch.Branch.hooks['post_pull']:
1081
def pull(self, overwrite=False, stop_revision=None,
1082
possible_transports=None, _hook_master=None, run_hooks=True,
1083
_override_hook_target=None, local=False, tag_selector=None):
1086
:param _hook_master: Private parameter - set the branch to
1087
be supplied as the master to pull hooks.
1088
:param run_hooks: Private parameter - if false, this branch
1089
is being called because it's the master of the primary branch,
1090
so it should not run its hooks.
1091
:param _override_hook_target: Private parameter - set the branch to be
1092
supplied as the target_branch to pull hooks.
1094
# This type of branch can't be bound.
1095
bound_location = self.target.get_bound_location()
1096
if local and not bound_location:
1097
raise errors.LocalRequiresBoundBranch()
1098
source_is_master = False
1099
with contextlib.ExitStack() as es:
1100
es.enter_context(self.source.lock_read())
1102
# bound_location comes from a config file, some care has to be
1103
# taken to relate it to source.user_url
1104
normalized = urlutils.normalize_url(bound_location)
1106
relpath = self.source.user_transport.relpath(normalized)
1107
source_is_master = (relpath == '')
1108
except (errors.PathNotChild, urlutils.InvalidURL):
1109
source_is_master = False
1110
if not local and bound_location and not source_is_master:
1111
# not pulling from master, so we need to update master.
1112
master_branch = self.target.get_master_branch(possible_transports)
1113
es.enter_context(master_branch.lock_write())
1114
# pull from source into master.
1115
master_branch.pull(self.source, overwrite, stop_revision,
1118
master_branch = None
1119
return self._basic_pull(stop_revision, overwrite, run_hooks,
1120
_override_hook_target,
1121
_hook_master=master_branch,
1122
tag_selector=tag_selector)
1124
def _basic_push(self, overwrite, stop_revision, tag_selector=None):
1125
if overwrite is True:
1126
overwrite = set(["history", "tags"])
1129
result = branch.BranchPushResult()
1130
result.source_branch = self.source
1131
result.target_branch = self.target
1132
result.old_revno, result.old_revid = self.target.last_revision_info()
1133
result.new_git_head, remote_refs = self._update_revisions(
1134
stop_revision, overwrite=("history" in overwrite),
1135
tag_selector=tag_selector)
1136
tags_ret = self.source.tags.merge_to(
1137
self.target.tags, "tags" in overwrite, ignore_master=True,
1138
selector=tag_selector)
1139
(result.tag_updates, result.tag_conflicts) = tags_ret
1140
result.new_revno, result.new_revid = self.target.last_revision_info()
1141
self.update_references(revid=result.new_revid)
1145
class InterGitBranch(branch.GenericInterBranch):
1146
"""InterBranch implementation that pulls between Git branches."""
1148
def fetch(self, stop_revision=None, fetch_tags=None, limit=None, lossy=False):
1149
raise NotImplementedError(self.fetch)
1152
class InterLocalGitRemoteGitBranch(InterGitBranch):
1153
"""InterBranch that copies from a local to a remote git branch."""
1156
def _get_branch_formats_to_test():
1157
from .remote import RemoteGitBranchFormat
1159
(LocalGitBranchFormat(), RemoteGitBranchFormat())]
1162
def is_compatible(self, source, target):
1163
from .remote import RemoteGitBranch
1164
return (isinstance(source, LocalGitBranch) and
1165
isinstance(target, RemoteGitBranch))
1167
def _basic_push(self, overwrite, stop_revision, tag_selector=None):
1168
result = GitBranchPushResult()
1169
result.source_branch = self.source
1170
result.target_branch = self.target
1171
if stop_revision is None:
1172
stop_revision = self.source.last_revision()
1174
def get_changed_refs(old_refs):
1175
old_ref = old_refs.get(self.target.ref, None)
1177
result.old_revid = revision.NULL_REVISION
1179
result.old_revid = self.target.lookup_foreign_revision_id(
1181
new_ref = self.source.repository.lookup_bzr_revision_id(
1184
if remote_divergence(
1186
self.source.repository._git.object_store):
1187
raise errors.DivergedBranches(self.source, self.target)
1188
refs = {self.target.ref: new_ref}
1189
result.new_revid = stop_revision
1191
self.source.repository._git.refs.as_dict(b"refs/tags").items()):
1192
if tag_selector and not tag_selector(name):
1194
if sha not in self.source.repository._git:
1195
trace.mutter('Ignoring missing SHA: %s', sha)
1197
refs[tag_name_to_ref(name)] = sha
1199
self.target.repository.send_pack(
1201
self.source.repository._git.object_store.generate_pack_data)
1205
class InterGitLocalGitBranch(InterGitBranch):
1206
"""InterBranch that copies from a remote to a local git branch."""
1209
def _get_branch_formats_to_test():
1210
from .remote import RemoteGitBranchFormat
1212
(RemoteGitBranchFormat(), LocalGitBranchFormat()),
1213
(LocalGitBranchFormat(), LocalGitBranchFormat())]
1216
def is_compatible(self, source, target):
1217
return (isinstance(source, GitBranch) and
1218
isinstance(target, LocalGitBranch))
1220
def fetch(self, stop_revision=None, fetch_tags=None, limit=None, lossy=False):
1221
interrepo = _mod_repository.InterRepository.get(
1222
self.source.repository, self.target.repository)
1223
if stop_revision is None:
1224
stop_revision = self.source.last_revision()
1225
if fetch_tags is None:
1226
c = self.source.get_config_stack()
1227
fetch_tags = c.get('branch.fetch_tags')
1228
determine_wants = interrepo.get_determine_wants_revids(
1229
[stop_revision], include_tags=fetch_tags)
1230
interrepo.fetch_objects(determine_wants, limit=limit, lossy=lossy)
1231
return _mod_repository.FetchResult()
1233
def _basic_push(self, overwrite=False, stop_revision=None, tag_selector=None):
1234
if overwrite is True:
1235
overwrite = set(["history", "tags"])
1238
result = GitBranchPushResult()
1239
result.source_branch = self.source
1240
result.target_branch = self.target
1241
result.old_revid = self.target.last_revision()
1242
refs, stop_revision = self.update_refs(stop_revision)
1243
self.target.generate_revision_history(
1245
(result.old_revid if ("history" not in overwrite) else None),
1246
other_branch=self.source)
1247
tags_ret = self.source.tags.merge_to(
1249
overwrite=("tags" in overwrite),
1250
selector=tag_selector)
1251
if isinstance(tags_ret, tuple):
1252
(result.tag_updates, result.tag_conflicts) = tags_ret
1254
result.tag_conflicts = tags_ret
1255
result.new_revid = self.target.last_revision()
1258
def update_refs(self, stop_revision=None):
1259
interrepo = _mod_repository.InterRepository.get(
1260
self.source.repository, self.target.repository)
1261
c = self.source.get_config_stack()
1262
fetch_tags = c.get('branch.fetch_tags')
1264
if stop_revision is None:
1265
result = interrepo.fetch(branches=[self.source.ref], include_tags=fetch_tags)
1267
head = result.refs[self.source.ref]
1269
stop_revision = revision.NULL_REVISION
1271
stop_revision = self.target.lookup_foreign_revision_id(head)
1273
result = interrepo.fetch(
1274
revision_id=stop_revision, include_tags=fetch_tags)
1275
return result.refs, stop_revision
1277
def pull(self, stop_revision=None, overwrite=False,
1278
possible_transports=None, run_hooks=True, local=False,
1280
# This type of branch can't be bound.
1282
raise errors.LocalRequiresBoundBranch()
1283
if overwrite is True:
1284
overwrite = set(["history", "tags"])
1288
result = GitPullResult()
1289
result.source_branch = self.source
1290
result.target_branch = self.target
1291
with self.target.lock_write(), self.source.lock_read():
1292
result.old_revid = self.target.last_revision()
1293
refs, stop_revision = self.update_refs(stop_revision)
1294
self.target.generate_revision_history(
1296
(result.old_revid if ("history" not in overwrite) else None),
1297
other_branch=self.source)
1298
tags_ret = self.source.tags.merge_to(
1299
self.target.tags, overwrite=("tags" in overwrite),
1300
selector=tag_selector)
1301
if isinstance(tags_ret, tuple):
1302
(result.tag_updates, result.tag_conflicts) = tags_ret
1304
result.tag_conflicts = tags_ret
1305
result.new_revid = self.target.last_revision()
1306
result.local_branch = None
1307
result.master_branch = result.target_branch
1309
for hook in branch.Branch.hooks['post_pull']:
1314
class InterToGitBranch(branch.GenericInterBranch):
1315
"""InterBranch implementation that pulls into a Git branch."""
1317
def __init__(self, source, target):
1318
super(InterToGitBranch, self).__init__(source, target)
1319
self.interrepo = _mod_repository.InterRepository.get(source.repository,
1323
def _get_branch_formats_to_test():
1325
default_format = branch.format_registry.get_default()
1326
except AttributeError:
1327
default_format = branch.BranchFormat._default_format
1328
from .remote import RemoteGitBranchFormat
1330
(default_format, LocalGitBranchFormat()),
1331
(default_format, RemoteGitBranchFormat())]
1334
def is_compatible(self, source, target):
1335
return (not isinstance(source, GitBranch) and
1336
isinstance(target, GitBranch))
1338
def _get_new_refs(self, stop_revision=None, fetch_tags=None,
1340
if not self.source.is_locked():
1341
raise errors.ObjectNotLocked(self.source)
1342
if stop_revision is None:
1343
(stop_revno, stop_revision) = self.source.last_revision_info()
1344
elif stop_revno is None:
1346
stop_revno = self.source.revision_id_to_revno(stop_revision)
1347
except errors.NoSuchRevision:
1349
if not isinstance(stop_revision, bytes):
1350
raise TypeError(stop_revision)
1351
main_ref = self.target.ref
1352
refs = {main_ref: (None, stop_revision)}
1353
if fetch_tags is None:
1354
c = self.source.get_config_stack()
1355
fetch_tags = c.get('branch.fetch_tags')
1356
for name, revid in self.source.tags.get_tag_dict().items():
1357
if self.source.repository.has_revision(revid):
1358
ref = tag_name_to_ref(name)
1359
if not check_ref_format(ref):
1360
warning("skipping tag with invalid characters %s (%s)",
1364
# FIXME: Skip tags that are not in the ancestry
1365
refs[ref] = (None, revid)
1366
return refs, main_ref, (stop_revno, stop_revision)
1368
def _update_refs(self, result, old_refs, new_refs, overwrite, tag_selector):
1369
mutter("updating refs. old refs: %r, new refs: %r",
1371
result.tag_updates = {}
1372
result.tag_conflicts = []
1373
ret = dict(old_refs)
1375
def ref_equals(refs, ref, git_sha, revid):
1380
if (value[0] is not None and
1381
git_sha is not None and
1382
value[0] == git_sha):
1384
if (value[1] is not None and
1385
revid is not None and
1388
# FIXME: If one side only has the git sha available and the other
1389
# only has the bzr revid, then this will cause us to show a tag as
1390
# updated that hasn't actually been updated.
1392
# FIXME: Check for diverged branches
1393
for ref, (git_sha, revid) in new_refs.items():
1394
if ref_equals(ret, ref, git_sha, revid):
1395
# Already up to date
1397
git_sha = old_refs[ref][0]
1399
revid = old_refs[ref][1]
1400
ret[ref] = new_refs[ref] = (git_sha, revid)
1401
elif ref not in ret or overwrite:
1403
tag_name = ref_to_tag_name(ref)
1407
if tag_selector and not tag_selector(tag_name):
1409
result.tag_updates[tag_name] = revid
1410
ret[ref] = (git_sha, revid)
1412
# FIXME: Check diverged
1416
name = ref_to_tag_name(ref)
1420
result.tag_conflicts.append(
1421
(name, revid, ret[name][1]))
1423
ret[ref] = (git_sha, revid)
1426
def fetch(self, stop_revision=None, fetch_tags=None, lossy=False,
1428
if stop_revision is None:
1429
stop_revision = self.source.last_revision()
1432
for k, v in self.source.tags.get_tag_dict().items():
1433
ret.append((None, v))
1434
ret.append((None, stop_revision))
1436
revidmap = self.interrepo.fetch_objects(ret, lossy=lossy, limit=limit)
1437
except NoPushSupport:
1438
raise errors.NoRoundtrippingSupport(self.source, self.target)
1439
return _mod_repository.FetchResult(revidmap={
1440
old_revid: new_revid
1441
for (old_revid, (new_sha, new_revid)) in revidmap.items()})
1443
def pull(self, overwrite=False, stop_revision=None, local=False,
1444
possible_transports=None, run_hooks=True, _stop_revno=None,
1446
result = GitBranchPullResult()
1447
result.source_branch = self.source
1448
result.target_branch = self.target
1449
with self.source.lock_read(), self.target.lock_write():
1450
new_refs, main_ref, stop_revinfo = self._get_new_refs(
1451
stop_revision, stop_revno=_stop_revno)
1453
def update_refs(old_refs):
1454
return self._update_refs(result, old_refs, new_refs, overwrite, tag_selector)
1456
result.revidmap, old_refs, new_refs = (
1457
self.interrepo.fetch_refs(update_refs, lossy=False))
1458
except NoPushSupport:
1459
raise errors.NoRoundtrippingSupport(self.source, self.target)
1460
(old_sha1, result.old_revid) = old_refs.get(
1461
main_ref, (ZERO_SHA, NULL_REVISION))
1462
if result.old_revid is None:
1463
result.old_revid = self.target.lookup_foreign_revision_id(
1465
result.new_revid = new_refs[main_ref][1]
1466
result.local_branch = None
1467
result.master_branch = self.target
1469
for hook in branch.Branch.hooks['post_pull']:
1473
def push(self, overwrite=False, stop_revision=None, lossy=False,
1474
_override_hook_source_branch=None, _stop_revno=None,
1476
result = GitBranchPushResult()
1477
result.source_branch = self.source
1478
result.target_branch = self.target
1479
result.local_branch = None
1480
result.master_branch = result.target_branch
1481
with self.source.lock_read(), self.target.lock_write():
1482
new_refs, main_ref, stop_revinfo = self._get_new_refs(
1483
stop_revision, stop_revno=_stop_revno)
1485
def update_refs(old_refs):
1486
return self._update_refs(result, old_refs, new_refs, overwrite, tag_selector)
1488
result.revidmap, old_refs, new_refs = (
1489
self.interrepo.fetch_refs(
1490
update_refs, lossy=lossy, overwrite=overwrite))
1491
except NoPushSupport:
1492
raise errors.NoRoundtrippingSupport(self.source, self.target)
1493
(old_sha1, result.old_revid) = old_refs.get(
1494
main_ref, (ZERO_SHA, NULL_REVISION))
1495
if lossy or result.old_revid is None:
1496
result.old_revid = self.target.lookup_foreign_revision_id(
1498
result.new_revid = new_refs[main_ref][1]
1499
(result.new_original_revno,
1500
result.new_original_revid) = stop_revinfo
1501
for hook in branch.Branch.hooks['post_push']:
1506
branch.InterBranch.register_optimiser(InterGitLocalGitBranch)
1507
branch.InterBranch.register_optimiser(InterFromGitBranch)
1508
branch.InterBranch.register_optimiser(InterToGitBranch)
1509
branch.InterBranch.register_optimiser(InterLocalGitRemoteGitBranch)
added
removed
breezy/git/branch.py
