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"""
20
from __future__ import absolute_import
22
from io import BytesIO
23
from collections import defaultdict
25
from dulwich.objects import (
29
from dulwich.repo import check_ref_format
37
repository as _mod_repository,
44
from ..foreign import ForeignBranch
45
from ..revision import (
48
from ..sixish import (
73
remote_refs_dict_to_tag_refs,
76
from .unpeel_map import (
85
def _calculate_revnos(branch):
86
if branch._format.stores_revno():
88
config = branch.get_config_stack()
89
return config.get('calculate_revnos')
92
class GitPullResult(branch.PullResult):
93
"""Result of a pull from a Git branch."""
95
def _lookup_revno(self, revid):
96
if not isinstance(revid, bytes):
97
raise TypeError(revid)
98
if not _calculate_revnos(self.target_branch):
100
# Try in source branch first, it'll be faster
101
with self.target_branch.lock_read():
102
return self.target_branch.revision_id_to_revno(revid)
106
return self._lookup_revno(self.old_revid)
110
return self._lookup_revno(self.new_revid)
113
class GitTags(tag.BasicTags):
114
"""Ref-based tag dictionary."""
116
def __init__(self, branch):
118
self.repository = branch.repository
120
def _merge_to_remote_git(self, target_repo, source_tag_refs,
125
def get_changed_refs(old_refs):
127
for ref_name, tag_name, peeled, unpeeled in (
128
source_tag_refs.iteritems()):
129
if old_refs.get(ref_name) == unpeeled:
131
elif overwrite or ref_name not in old_refs:
132
ret[ref_name] = unpeeled
133
updates[tag_name] = target_repo.lookup_foreign_revision_id(
138
self.repository.lookup_foreign_revision_id(peeled),
139
target_repo.lookup_foreign_revision_id(
140
old_refs[ref_name])))
142
target_repo.controldir.send_pack(
143
get_changed_refs, lambda have, want: [])
144
return updates, conflicts
146
def _merge_to_local_git(self, target_repo, source_tag_refs,
150
for ref_name, tag_name, peeled, unpeeled in source_tag_refs:
151
if target_repo._git.refs.get(ref_name) == unpeeled:
153
elif overwrite or ref_name not in target_repo._git.refs:
155
updates[tag_name] = (
156
target_repo.lookup_foreign_revision_id(peeled))
158
trace.warning('%s does not point to a valid object',
161
except NotCommitError:
162
trace.warning('%s points to a non-commit object',
165
target_repo._git.refs[ref_name] = unpeeled or peeled
168
source_revid = self.repository.lookup_foreign_revision_id(
170
target_revid = target_repo.lookup_foreign_revision_id(
171
target_repo._git.refs[ref_name])
173
trace.warning('%s does not point to a valid object',
176
except NotCommitError:
177
trace.warning('%s points to a non-commit object',
180
conflicts.append((tag_name, source_revid, target_revid))
181
return updates, conflicts
183
def _merge_to_git(self, to_tags, source_tag_refs, overwrite=False):
184
target_repo = to_tags.repository
185
if self.repository.has_same_location(target_repo):
188
if getattr(target_repo, "_git", None):
189
return self._merge_to_local_git(
190
target_repo, source_tag_refs, overwrite)
192
return self._merge_to_remote_git(
193
target_repo, source_tag_refs, overwrite)
195
to_tags.branch._tag_refs = None
197
def _merge_to_non_git(self, to_tags, source_tag_refs, overwrite=False):
198
unpeeled_map = defaultdict(set)
201
result = dict(to_tags.get_tag_dict())
202
for ref_name, tag_name, peeled, unpeeled in source_tag_refs:
203
if unpeeled is not None:
204
unpeeled_map[peeled].add(unpeeled)
206
bzr_revid = self.branch.lookup_foreign_revision_id(peeled)
207
except NotCommitError:
209
if result.get(tag_name) == bzr_revid:
211
elif tag_name not in result or overwrite:
212
result[tag_name] = bzr_revid
213
updates[tag_name] = bzr_revid
215
conflicts.append((tag_name, bzr_revid, result[tag_name]))
216
to_tags._set_tag_dict(result)
217
if len(unpeeled_map) > 0:
218
map_file = UnpeelMap.from_repository(to_tags.branch.repository)
219
map_file.update(unpeeled_map)
220
map_file.save_in_repository(to_tags.branch.repository)
221
return updates, conflicts
223
def merge_to(self, to_tags, overwrite=False, ignore_master=False,
224
source_tag_refs=None):
225
"""See Tags.merge_to."""
226
if source_tag_refs is None:
227
source_tag_refs = self.branch.get_tag_refs()
230
if isinstance(to_tags, GitTags):
231
return self._merge_to_git(to_tags, source_tag_refs,
237
master = to_tags.branch.get_master_branch()
238
if master is not None:
241
updates, conflicts = self._merge_to_non_git(
242
to_tags, 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)
248
updates.update(extra_updates)
249
conflicts += extra_conflicts
250
return updates, conflicts
252
if master is not None:
255
def get_tag_dict(self):
257
for (ref_name, tag_name, peeled, unpeeled) in (
258
self.branch.get_tag_refs()):
260
bzr_revid = self.branch.lookup_foreign_revision_id(peeled)
261
except NotCommitError:
264
ret[tag_name] = bzr_revid
268
class LocalGitTagDict(GitTags):
269
"""Dictionary with tags in a local repository."""
271
def __init__(self, branch):
272
super(LocalGitTagDict, self).__init__(branch)
273
self.refs = self.repository.controldir._git.refs
275
def _set_tag_dict(self, to_dict):
276
extra = set(self.refs.allkeys())
277
for k, revid in viewitems(to_dict):
278
name = tag_name_to_ref(k)
281
self.set_tag(k, revid)
284
del self.repository._git[name]
286
def set_tag(self, name, revid):
288
git_sha, mapping = self.branch.lookup_bzr_revision_id(revid)
289
except errors.NoSuchRevision:
290
raise errors.GhostTagsNotSupported(self)
291
self.refs[tag_name_to_ref(name)] = git_sha
292
self.branch._tag_refs = None
294
def delete_tag(self, name):
295
ref = tag_name_to_ref(name)
296
if ref not in self.refs:
297
raise errors.NoSuchTag(name)
299
self.branch._tag_refs = None
302
class GitBranchFormat(branch.BranchFormat):
304
def network_name(self):
307
def supports_tags(self):
310
def supports_leaving_lock(self):
313
def supports_tags_referencing_ghosts(self):
316
def tags_are_versioned(self):
319
def get_foreign_tests_branch_factory(self):
320
from .tests.test_branch import ForeignTestsBranchFactory
321
return ForeignTestsBranchFactory()
323
def make_tags(self, branch):
326
except AttributeError:
328
if getattr(branch.repository, "_git", None) is None:
329
from .remote import RemoteGitTagDict
330
return RemoteGitTagDict(branch)
332
return LocalGitTagDict(branch)
334
def initialize(self, a_controldir, name=None, repository=None,
335
append_revisions_only=None):
336
raise NotImplementedError(self.initialize)
338
def get_reference(self, controldir, name=None):
339
return controldir.get_branch_reference(name=name)
341
def set_reference(self, controldir, name, target):
342
return controldir.set_branch_reference(target, name)
344
def stores_revno(self):
345
"""True if this branch format store revision numbers."""
349
class LocalGitBranchFormat(GitBranchFormat):
351
def get_format_description(self):
352
return 'Local Git Branch'
355
def _matchingcontroldir(self):
356
from .dir import LocalGitControlDirFormat
357
return LocalGitControlDirFormat()
359
def initialize(self, a_controldir, name=None, repository=None,
360
append_revisions_only=None):
361
from .dir import LocalGitDir
362
if not isinstance(a_controldir, LocalGitDir):
363
raise errors.IncompatibleFormat(self, a_controldir._format)
364
return a_controldir.create_branch(
365
repository=repository, name=name,
366
append_revisions_only=append_revisions_only)
369
class GitBranch(ForeignBranch):
370
"""An adapter to git repositories for bzr Branch objects."""
373
def control_transport(self):
374
return self._control_transport
377
def user_transport(self):
378
return self._user_transport
380
def __init__(self, controldir, repository, ref, format):
381
self.repository = repository
382
self._format = format
383
self.controldir = controldir
384
self._lock_mode = None
386
super(GitBranch, self).__init__(repository.get_mapping())
389
self._user_transport = controldir.user_transport.clone('.')
390
self._control_transport = controldir.control_transport.clone('.')
391
self._tag_refs = None
394
self.name = ref_to_branch_name(ref)
397
if self.ref is not None:
398
params = {"ref": urlutils.escape(self.ref)}
401
params = {"branch": urlutils.escape(self.name)}
402
for k, v in params.items():
403
self._user_transport.set_segment_parameter(k, v)
404
self._control_transport.set_segment_parameter(k, v)
405
self.base = controldir.user_transport.base
407
def _get_checkout_format(self, lightweight=False):
408
"""Return the most suitable metadir for a checkout of this branch.
409
Weaves are used if this branch's repository uses weaves.
412
return controldir.format_registry.make_controldir("git")
414
return controldir.format_registry.make_controldir("default")
416
def get_child_submit_format(self):
417
"""Return the preferred format of submissions to this branch."""
418
ret = self.get_config_stack().get("child_submit_format")
423
def get_config(self):
424
return GitBranchConfig(self)
426
def get_config_stack(self):
427
return GitBranchStack(self)
429
def _get_nick(self, local=False, possible_master_transports=None):
430
"""Find the nick name for this branch.
434
if getattr(self.repository, '_git', None):
435
cs = self.repository._git.get_config_stack()
437
return cs.get((b"branch", self.name.encode('utf-8')),
438
b"nick").decode("utf-8")
441
return self.name or u"HEAD"
443
def _set_nick(self, nick):
444
cf = self.repository._git.get_config()
445
cf.set((b"branch", self.name.encode('utf-8')),
446
b"nick", nick.encode("utf-8"))
449
self.repository._git._put_named_file('config', f.getvalue())
451
nick = property(_get_nick, _set_nick)
454
return "<%s(%r, %r)>" % (self.__class__.__name__, self.repository.base,
457
def generate_revision_history(self, revid, last_rev=None,
459
if last_rev is not None:
460
graph = self.repository.get_graph()
461
if not graph.is_ancestor(last_rev, revid):
462
# our previous tip is not merged into stop_revision
463
raise errors.DivergedBranches(self, other_branch)
465
self.set_last_revision(revid)
467
def lock_write(self, token=None):
468
if token is not None:
469
raise errors.TokenLockingNotSupported(self)
471
if self._lock_mode == 'r':
472
raise errors.ReadOnlyError(self)
473
self._lock_count += 1
476
self._lock_mode = 'w'
478
self.repository.lock_write()
479
return lock.LogicalLockResult(self.unlock)
481
def leave_lock_in_place(self):
482
raise NotImplementedError(self.leave_lock_in_place)
484
def dont_leave_lock_in_place(self):
485
raise NotImplementedError(self.dont_leave_lock_in_place)
487
def get_stacked_on_url(self):
488
# Git doesn't do stacking (yet...)
489
raise branch.UnstackableBranchFormat(self._format, self.base)
491
def _get_push_origin(self, cs):
492
"""Get the name for the push origin.
494
The exact behaviour is documented in the git-config(1) manpage.
497
return cs.get((b'branch', self.name.encode('utf-8')), b'pushRemote')
500
return cs.get((b'branch', ), b'remote')
503
return cs.get((b'branch', self.name.encode('utf-8')), b'remote')
507
def _get_origin(self, cs):
509
return cs.get((b'branch', self.name.encode('utf-8')), b'remote')
513
def _get_related_push_branch(self, cs):
514
remote = self._get_push_origin(cs)
516
location = cs.get((b"remote", remote), b"url")
520
return git_url_to_bzr_url(location.decode('utf-8'), ref=self.ref)
522
def _get_related_merge_branch(self, cs):
523
remote = self._get_origin(cs)
525
location = cs.get((b"remote", remote), b"url")
530
ref = cs.get((b"branch", remote), b"merge")
534
return git_url_to_bzr_url(location.decode('utf-8'), ref=ref)
536
def _get_parent_location(self):
537
"""See Branch.get_parent()."""
538
cs = self.repository._git.get_config_stack()
539
return self._get_related_merge_branch(cs)
541
def _write_git_config(self, cs):
544
self.repository._git._put_named_file('config', f.getvalue())
546
def set_parent(self, location):
547
cs = self.repository._git.get_config()
548
remote = self._get_origin(cs)
549
this_url = urlutils.split_segment_parameters(self.user_url)[0]
550
target_url, branch, ref = bzr_url_to_git_url(location)
551
location = urlutils.relative_url(this_url, target_url)
552
cs.set((b"remote", remote), b"url", location)
554
cs.set((b"branch", remote), b"merge", branch_name_to_ref(branch))
556
cs.set((b"branch", remote), b"merge", ref)
558
# TODO(jelmer): Maybe unset rather than setting to HEAD?
559
cs.set((b"branch", remote), b"merge", b'HEAD')
560
self._write_git_config(cs)
562
def break_lock(self):
563
raise NotImplementedError(self.break_lock)
567
if self._lock_mode not in ('r', 'w'):
568
raise ValueError(self._lock_mode)
569
self._lock_count += 1
571
self._lock_mode = 'r'
573
self.repository.lock_read()
574
return lock.LogicalLockResult(self.unlock)
576
def peek_lock_mode(self):
577
return self._lock_mode
580
return (self._lock_mode is not None)
585
def _unlock_ref(self):
589
"""See Branch.unlock()."""
590
if self._lock_count == 0:
591
raise errors.LockNotHeld(self)
593
self._lock_count -= 1
594
if self._lock_count == 0:
595
if self._lock_mode == 'w':
597
self._lock_mode = None
598
self._clear_cached_state()
600
self.repository.unlock()
602
def get_physical_lock_status(self):
605
def last_revision(self):
606
with self.lock_read():
607
# perhaps should escape this ?
608
if self.head is None:
609
return revision.NULL_REVISION
610
return self.lookup_foreign_revision_id(self.head)
612
def _basic_push(self, target, overwrite=False, stop_revision=None):
613
return branch.InterBranch.get(self, target)._basic_push(
614
overwrite, stop_revision)
616
def lookup_foreign_revision_id(self, foreign_revid):
618
return self.repository.lookup_foreign_revision_id(foreign_revid,
622
return self.mapping.revision_id_foreign_to_bzr(foreign_revid)
624
def lookup_bzr_revision_id(self, revid):
625
return self.repository.lookup_bzr_revision_id(
626
revid, mapping=self.mapping)
628
def get_unshelver(self, tree):
629
raise errors.StoringUncommittedNotSupported(self)
631
def _clear_cached_state(self):
632
super(GitBranch, self)._clear_cached_state()
633
self._tag_refs = None
635
def _iter_tag_refs(self, refs):
636
"""Iterate over the tag refs.
638
:param refs: Refs dictionary (name -> git sha1)
639
:return: iterator over (ref_name, tag_name, peeled_sha1, unpeeled_sha1)
641
raise NotImplementedError(self._iter_tag_refs)
643
def get_tag_refs(self):
644
with self.lock_read():
645
if self._tag_refs is None:
646
self._tag_refs = list(self._iter_tag_refs())
647
return self._tag_refs
649
def import_last_revision_info_and_tags(self, source, revno, revid,
651
"""Set the last revision info, importing from another repo if necessary.
653
This is used by the bound branch code to upload a revision to
654
the master branch first before updating the tip of the local branch.
655
Revisions referenced by source's tags are also transferred.
657
:param source: Source branch to optionally fetch from
658
:param revno: Revision number of the new tip
659
:param revid: Revision id of the new tip
660
:param lossy: Whether to discard metadata that can not be
662
:return: Tuple with the new revision number and revision id
663
(should only be different from the arguments when lossy=True)
665
push_result = source.push(
666
self, stop_revision=revid, lossy=lossy, _stop_revno=revno)
667
return (push_result.new_revno, push_result.new_revid)
669
def reconcile(self, thorough=True):
670
"""Make sure the data stored in this branch is consistent."""
671
from ..reconcile import ReconcileResult
673
return ReconcileResult()
676
class LocalGitBranch(GitBranch):
677
"""A local Git branch."""
679
def __init__(self, controldir, repository, ref):
680
super(LocalGitBranch, self).__init__(controldir, repository, ref,
681
LocalGitBranchFormat())
683
def create_checkout(self, to_location, revision_id=None, lightweight=False,
684
accelerator_tree=None, hardlink=False):
685
t = transport.get_transport(to_location)
687
format = self._get_checkout_format(lightweight=lightweight)
688
checkout = format.initialize_on_transport(t)
690
from_branch = checkout.set_branch_reference(target_branch=self)
692
policy = checkout.determine_repository_policy()
693
policy.acquire_repository()
694
checkout_branch = checkout.create_branch()
695
checkout_branch.bind(self)
696
checkout_branch.pull(self, stop_revision=revision_id)
698
return checkout.create_workingtree(
699
revision_id, from_branch=from_branch, hardlink=hardlink)
702
self._ref_lock = self.repository._git.refs.lock_ref(self.ref)
704
def _unlock_ref(self):
705
self._ref_lock.unlock()
707
def break_lock(self):
708
self.repository._git.refs.unlock_ref(self.ref)
710
def fetch(self, from_branch, last_revision=None, limit=None):
711
return branch.InterBranch.get(from_branch, self).fetch(
712
stop_revision=last_revision, limit=limit)
714
def _gen_revision_history(self):
715
if self.head is None:
717
last_revid = self.last_revision()
718
graph = self.repository.get_graph()
720
ret = list(graph.iter_lefthand_ancestry(
721
last_revid, (revision.NULL_REVISION, )))
722
except errors.RevisionNotPresent as e:
723
raise errors.GhostRevisionsHaveNoRevno(last_revid, e.revision_id)
729
return self.repository._git.refs[self.ref]
733
def _read_last_revision_info(self):
734
last_revid = self.last_revision()
735
graph = self.repository.get_graph()
737
revno = graph.find_distance_to_null(
738
last_revid, [(revision.NULL_REVISION, 0)])
739
except errors.GhostRevisionsHaveNoRevno:
741
return revno, last_revid
743
def set_last_revision_info(self, revno, revision_id):
744
self.set_last_revision(revision_id)
745
self._last_revision_info_cache = revno, revision_id
747
def set_last_revision(self, revid):
748
if not revid or not isinstance(revid, bytes):
749
raise errors.InvalidRevisionId(revision_id=revid, branch=self)
750
if revid == NULL_REVISION:
753
(newhead, self.mapping) = self.repository.lookup_bzr_revision_id(
755
if self.mapping is None:
757
self._set_head(newhead)
759
def _set_head(self, value):
760
if value == ZERO_SHA:
761
raise ValueError(value)
764
del self.repository._git.refs[self.ref]
766
self.repository._git.refs[self.ref] = self._head
767
self._clear_cached_state()
769
head = property(_get_head, _set_head)
771
def get_push_location(self):
772
"""See Branch.get_push_location."""
773
push_loc = self.get_config_stack().get('push_location')
774
if push_loc is not None:
776
cs = self.repository._git.get_config_stack()
777
return self._get_related_push_branch(cs)
779
def set_push_location(self, location):
780
"""See Branch.set_push_location."""
781
self.get_config().set_user_option('push_location', location,
782
store=config.STORE_LOCATION)
784
def supports_tags(self):
787
def store_uncommitted(self, creator):
788
raise errors.StoringUncommittedNotSupported(self)
790
def _iter_tag_refs(self):
791
"""Iterate over the tag refs.
793
:param refs: Refs dictionary (name -> git sha1)
794
:return: iterator over (ref_name, tag_name, peeled_sha1, unpeeled_sha1)
796
refs = self.repository.controldir.get_refs_container()
797
for ref_name, unpeeled in viewitems(refs.as_dict()):
799
tag_name = ref_to_tag_name(ref_name)
800
except (ValueError, UnicodeDecodeError):
802
peeled = refs.get_peeled(ref_name)
805
if not isinstance(tag_name, text_type):
806
raise TypeError(tag_name)
807
yield (ref_name, tag_name, peeled, unpeeled)
809
def create_memorytree(self):
810
from .memorytree import GitMemoryTree
811
return GitMemoryTree(self, self.repository._git.object_store,
814
def reference_parent(self, path, possible_transports=None):
815
"""Return the parent branch for a tree-reference.
817
:param path: The path of the nested tree in the tree
818
:return: A branch associated with the nested tree
820
# FIXME should provide multiple branches, based on config
821
url = urlutils.join(self.user_url, path)
822
return branch.Branch.open(
824
possible_transports=possible_transports)
827
def _quick_lookup_revno(local_branch, remote_branch, revid):
828
if not isinstance(revid, bytes):
829
raise TypeError(revid)
830
# Try in source branch first, it'll be faster
831
with local_branch.lock_read():
832
if not _calculate_revnos(local_branch):
835
return local_branch.revision_id_to_revno(revid)
836
except errors.NoSuchRevision:
837
graph = local_branch.repository.get_graph()
839
return graph.find_distance_to_null(
840
revid, [(revision.NULL_REVISION, 0)])
841
except errors.GhostRevisionsHaveNoRevno:
842
if not _calculate_revnos(remote_branch):
844
# FIXME: Check using graph.find_distance_to_null() ?
845
with remote_branch.lock_read():
846
return remote_branch.revision_id_to_revno(revid)
849
class GitBranchPullResult(branch.PullResult):
852
super(GitBranchPullResult, self).__init__()
853
self.new_git_head = None
854
self._old_revno = None
855
self._new_revno = None
857
def report(self, to_file):
859
if self.old_revid == self.new_revid:
860
to_file.write('No revisions to pull.\n')
861
elif self.new_git_head is not None:
862
to_file.write('Now on revision %d (git sha: %s).\n' %
863
(self.new_revno, self.new_git_head))
865
to_file.write('Now on revision %d.\n' % (self.new_revno,))
866
self._show_tag_conficts(to_file)
868
def _lookup_revno(self, revid):
869
return _quick_lookup_revno(self.target_branch, self.source_branch,
872
def _get_old_revno(self):
873
if self._old_revno is not None:
874
return self._old_revno
875
return self._lookup_revno(self.old_revid)
877
def _set_old_revno(self, revno):
878
self._old_revno = revno
880
old_revno = property(_get_old_revno, _set_old_revno)
882
def _get_new_revno(self):
883
if self._new_revno is not None:
884
return self._new_revno
885
return self._lookup_revno(self.new_revid)
887
def _set_new_revno(self, revno):
888
self._new_revno = revno
890
new_revno = property(_get_new_revno, _set_new_revno)
893
class GitBranchPushResult(branch.BranchPushResult):
895
def _lookup_revno(self, revid):
896
return _quick_lookup_revno(self.source_branch, self.target_branch,
901
return self._lookup_revno(self.old_revid)
905
new_original_revno = getattr(self, "new_original_revno", None)
906
if new_original_revno:
907
return new_original_revno
908
if getattr(self, "new_original_revid", None) is not None:
909
return self._lookup_revno(self.new_original_revid)
910
return self._lookup_revno(self.new_revid)
913
class InterFromGitBranch(branch.GenericInterBranch):
914
"""InterBranch implementation that pulls from Git into bzr."""
917
def _get_branch_formats_to_test():
919
default_format = branch.format_registry.get_default()
920
except AttributeError:
921
default_format = branch.BranchFormat._default_format
922
from .remote import RemoteGitBranchFormat
924
(RemoteGitBranchFormat(), default_format),
925
(LocalGitBranchFormat(), default_format)]
928
def _get_interrepo(self, source, target):
929
return _mod_repository.InterRepository.get(
930
source.repository, target.repository)
933
def is_compatible(cls, source, target):
934
if not isinstance(source, GitBranch):
936
if isinstance(target, GitBranch):
937
# InterLocalGitRemoteGitBranch or InterToGitBranch should be used
939
if (getattr(cls._get_interrepo(source, target), "fetch_objects", None)
941
# fetch_objects is necessary for this to work
945
def fetch(self, stop_revision=None, fetch_tags=None, limit=None):
946
self.fetch_objects(stop_revision, fetch_tags=fetch_tags, limit=limit)
948
def fetch_objects(self, stop_revision, fetch_tags, limit=None):
949
interrepo = self._get_interrepo(self.source, self.target)
950
if fetch_tags is None:
951
c = self.source.get_config_stack()
952
fetch_tags = c.get('branch.fetch_tags')
954
def determine_wants(heads):
955
if stop_revision is None:
957
head = heads[self.source.ref]
959
self._last_revid = revision.NULL_REVISION
961
self._last_revid = self.source.lookup_foreign_revision_id(
964
self._last_revid = stop_revision
965
real = interrepo.get_determine_wants_revids(
966
[self._last_revid], include_tags=fetch_tags)
968
pack_hint, head, refs = interrepo.fetch_objects(
969
determine_wants, self.source.mapping, limit=limit)
970
if (pack_hint is not None and
971
self.target.repository._format.pack_compresses):
972
self.target.repository.pack(hint=pack_hint)
975
def _update_revisions(self, stop_revision=None, overwrite=False):
976
head, refs = self.fetch_objects(stop_revision, fetch_tags=None)
978
prev_last_revid = None
980
prev_last_revid = self.target.last_revision()
981
self.target.generate_revision_history(
982
self._last_revid, last_rev=prev_last_revid,
983
other_branch=self.source)
986
def _basic_pull(self, stop_revision, overwrite, run_hooks,
987
_override_hook_target, _hook_master):
988
if overwrite is True:
989
overwrite = set(["history", "tags"])
992
result = GitBranchPullResult()
993
result.source_branch = self.source
994
if _override_hook_target is None:
995
result.target_branch = self.target
997
result.target_branch = _override_hook_target
998
with self.target.lock_write(), self.source.lock_read():
999
# We assume that during 'pull' the target repository is closer than
1001
(result.old_revno, result.old_revid) = \
1002
self.target.last_revision_info()
1003
result.new_git_head, remote_refs = self._update_revisions(
1004
stop_revision, overwrite=("history" in overwrite))
1005
tags_ret = self.source.tags.merge_to(
1006
self.target.tags, ("tags" in overwrite), ignore_master=True)
1007
if isinstance(tags_ret, tuple):
1008
result.tag_updates, result.tag_conflicts = tags_ret
1010
result.tag_conflicts = tags_ret
1011
(result.new_revno, result.new_revid) = \
1012
self.target.last_revision_info()
1014
result.master_branch = _hook_master
1015
result.local_branch = result.target_branch
1017
result.master_branch = result.target_branch
1018
result.local_branch = None
1020
for hook in branch.Branch.hooks['post_pull']:
1024
def pull(self, overwrite=False, stop_revision=None,
1025
possible_transports=None, _hook_master=None, run_hooks=True,
1026
_override_hook_target=None, local=False):
1029
:param _hook_master: Private parameter - set the branch to
1030
be supplied as the master to pull hooks.
1031
:param run_hooks: Private parameter - if false, this branch
1032
is being called because it's the master of the primary branch,
1033
so it should not run its hooks.
1034
:param _override_hook_target: Private parameter - set the branch to be
1035
supplied as the target_branch to pull hooks.
1037
# This type of branch can't be bound.
1038
bound_location = self.target.get_bound_location()
1039
if local and not bound_location:
1040
raise errors.LocalRequiresBoundBranch()
1041
master_branch = None
1042
source_is_master = False
1043
self.source.lock_read()
1045
# bound_location comes from a config file, some care has to be
1046
# taken to relate it to source.user_url
1047
normalized = urlutils.normalize_url(bound_location)
1049
relpath = self.source.user_transport.relpath(normalized)
1050
source_is_master = (relpath == '')
1051
except (errors.PathNotChild, urlutils.InvalidURL):
1052
source_is_master = False
1053
if not local and bound_location and not source_is_master:
1054
# not pulling from master, so we need to update master.
1055
master_branch = self.target.get_master_branch(possible_transports)
1056
master_branch.lock_write()
1060
# pull from source into master.
1061
master_branch.pull(self.source, overwrite, stop_revision,
1063
result = self._basic_pull(stop_revision, overwrite, run_hooks,
1064
_override_hook_target,
1065
_hook_master=master_branch)
1067
self.source.unlock()
1070
master_branch.unlock()
1073
def _basic_push(self, overwrite, stop_revision):
1074
if overwrite is True:
1075
overwrite = set(["history", "tags"])
1078
result = branch.BranchPushResult()
1079
result.source_branch = self.source
1080
result.target_branch = self.target
1081
result.old_revno, result.old_revid = self.target.last_revision_info()
1082
result.new_git_head, remote_refs = self._update_revisions(
1083
stop_revision, overwrite=("history" in overwrite))
1084
tags_ret = self.source.tags.merge_to(
1085
self.target.tags, "tags" in overwrite, ignore_master=True)
1086
(result.tag_updates, result.tag_conflicts) = tags_ret
1087
result.new_revno, result.new_revid = self.target.last_revision_info()
1091
class InterGitBranch(branch.GenericInterBranch):
1092
"""InterBranch implementation that pulls between Git branches."""
1094
def fetch(self, stop_revision=None, fetch_tags=None, limit=None):
1095
raise NotImplementedError(self.fetch)
1098
class InterLocalGitRemoteGitBranch(InterGitBranch):
1099
"""InterBranch that copies from a local to a remote git branch."""
1102
def _get_branch_formats_to_test():
1103
from .remote import RemoteGitBranchFormat
1105
(LocalGitBranchFormat(), RemoteGitBranchFormat())]
1108
def is_compatible(self, source, target):
1109
from .remote import RemoteGitBranch
1110
return (isinstance(source, LocalGitBranch) and
1111
isinstance(target, RemoteGitBranch))
1113
def _basic_push(self, overwrite, stop_revision):
1114
result = GitBranchPushResult()
1115
result.source_branch = self.source
1116
result.target_branch = self.target
1117
if stop_revision is None:
1118
stop_revision = self.source.last_revision()
1120
def get_changed_refs(old_refs):
1121
old_ref = old_refs.get(self.target.ref, None)
1123
result.old_revid = revision.NULL_REVISION
1125
result.old_revid = self.target.lookup_foreign_revision_id(
1127
new_ref = self.source.repository.lookup_bzr_revision_id(
1130
if remote_divergence(
1132
self.source.repository._git.object_store):
1133
raise errors.DivergedBranches(self.source, self.target)
1134
refs = {self.target.ref: new_ref}
1135
result.new_revid = stop_revision
1136
for name, sha in viewitems(
1137
self.source.repository._git.refs.as_dict(b"refs/tags")):
1138
refs[tag_name_to_ref(name)] = sha
1140
self.target.repository.send_pack(
1142
self.source.repository._git.object_store.generate_pack_data)
1146
class InterGitLocalGitBranch(InterGitBranch):
1147
"""InterBranch that copies from a remote to a local git branch."""
1150
def _get_branch_formats_to_test():
1151
from .remote import RemoteGitBranchFormat
1153
(RemoteGitBranchFormat(), LocalGitBranchFormat()),
1154
(LocalGitBranchFormat(), LocalGitBranchFormat())]
1157
def is_compatible(self, source, target):
1158
return (isinstance(source, GitBranch) and
1159
isinstance(target, LocalGitBranch))
1161
def fetch(self, stop_revision=None, fetch_tags=None, limit=None):
1162
interrepo = _mod_repository.InterRepository.get(self.source.repository,
1163
self.target.repository)
1164
if stop_revision is None:
1165
stop_revision = self.source.last_revision()
1166
if fetch_tags is None:
1167
c = self.source.get_config_stack()
1168
fetch_tags = c.get('branch.fetch_tags')
1169
determine_wants = interrepo.get_determine_wants_revids(
1170
[stop_revision], include_tags=fetch_tags)
1171
interrepo.fetch_objects(determine_wants, limit=limit)
1173
def _basic_push(self, overwrite=False, stop_revision=None):
1174
if overwrite is True:
1175
overwrite = set(["history", "tags"])
1178
result = GitBranchPushResult()
1179
result.source_branch = self.source
1180
result.target_branch = self.target
1181
result.old_revid = self.target.last_revision()
1182
refs, stop_revision = self.update_refs(stop_revision)
1183
self.target.generate_revision_history(
1185
(result.old_revid if ("history" not in overwrite) else None),
1186
other_branch=self.source)
1187
tags_ret = self.source.tags.merge_to(
1189
source_tag_refs=remote_refs_dict_to_tag_refs(refs),
1190
overwrite=("tags" in overwrite))
1191
if isinstance(tags_ret, tuple):
1192
(result.tag_updates, result.tag_conflicts) = tags_ret
1194
result.tag_conflicts = tags_ret
1195
result.new_revid = self.target.last_revision()
1198
def update_refs(self, stop_revision=None):
1199
interrepo = _mod_repository.InterRepository.get(
1200
self.source.repository, self.target.repository)
1201
c = self.source.get_config_stack()
1202
fetch_tags = c.get('branch.fetch_tags')
1204
if stop_revision is None:
1205
refs = interrepo.fetch(branches=[self.source.ref], include_tags=fetch_tags)
1207
head = refs[self.source.ref]
1209
stop_revision = revision.NULL_REVISION
1211
stop_revision = self.target.lookup_foreign_revision_id(head)
1213
refs = interrepo.fetch(
1214
revision_id=stop_revision, include_tags=fetch_tags)
1215
return refs, stop_revision
1217
def pull(self, stop_revision=None, overwrite=False,
1218
possible_transports=None, run_hooks=True, local=False):
1219
# This type of branch can't be bound.
1221
raise errors.LocalRequiresBoundBranch()
1222
if overwrite is True:
1223
overwrite = set(["history", "tags"])
1227
result = GitPullResult()
1228
result.source_branch = self.source
1229
result.target_branch = self.target
1230
with self.target.lock_write(), self.source.lock_read():
1231
result.old_revid = self.target.last_revision()
1232
refs, stop_revision = self.update_refs(stop_revision)
1233
self.target.generate_revision_history(
1235
(result.old_revid if ("history" not in overwrite) else None),
1236
other_branch=self.source)
1237
tags_ret = self.source.tags.merge_to(
1238
self.target.tags, overwrite=("tags" in overwrite),
1239
source_tag_refs=remote_refs_dict_to_tag_refs(refs))
1240
if isinstance(tags_ret, tuple):
1241
(result.tag_updates, result.tag_conflicts) = tags_ret
1243
result.tag_conflicts = tags_ret
1244
result.new_revid = self.target.last_revision()
1245
result.local_branch = None
1246
result.master_branch = result.target_branch
1248
for hook in branch.Branch.hooks['post_pull']:
1253
class InterToGitBranch(branch.GenericInterBranch):
1254
"""InterBranch implementation that pulls into a Git branch."""
1256
def __init__(self, source, target):
1257
super(InterToGitBranch, self).__init__(source, target)
1258
self.interrepo = _mod_repository.InterRepository.get(source.repository,
1262
def _get_branch_formats_to_test():
1264
default_format = branch.format_registry.get_default()
1265
except AttributeError:
1266
default_format = branch.BranchFormat._default_format
1267
from .remote import RemoteGitBranchFormat
1269
(default_format, LocalGitBranchFormat()),
1270
(default_format, RemoteGitBranchFormat())]
1273
def is_compatible(self, source, target):
1274
return (not isinstance(source, GitBranch) and
1275
isinstance(target, GitBranch))
1277
def _get_new_refs(self, stop_revision=None, fetch_tags=None,
1279
if not self.source.is_locked():
1280
raise errors.ObjectNotLocked(self.source)
1281
if stop_revision is None:
1282
(stop_revno, stop_revision) = self.source.last_revision_info()
1283
elif stop_revno is None:
1285
stop_revno = self.source.revision_id_to_revno(stop_revision)
1286
except errors.NoSuchRevision:
1288
if not isinstance(stop_revision, bytes):
1289
raise TypeError(stop_revision)
1290
main_ref = self.target.ref
1291
refs = {main_ref: (None, stop_revision)}
1292
if fetch_tags is None:
1293
c = self.source.get_config_stack()
1294
fetch_tags = c.get('branch.fetch_tags')
1295
for name, revid in viewitems(self.source.tags.get_tag_dict()):
1296
if self.source.repository.has_revision(revid):
1297
ref = tag_name_to_ref(name)
1298
if not check_ref_format(ref):
1299
warning("skipping tag with invalid characters %s (%s)",
1303
# FIXME: Skip tags that are not in the ancestry
1304
refs[ref] = (None, revid)
1305
return refs, main_ref, (stop_revno, stop_revision)
1307
def _update_refs(self, result, old_refs, new_refs, overwrite):
1308
mutter("updating refs. old refs: %r, new refs: %r",
1310
result.tag_updates = {}
1311
result.tag_conflicts = []
1312
ret = dict(old_refs)
1314
def ref_equals(refs, ref, git_sha, revid):
1319
if (value[0] is not None and
1320
git_sha is not None and
1321
value[0] == git_sha):
1323
if (value[1] is not None and
1324
revid is not None and
1327
# FIXME: If one side only has the git sha available and the other
1328
# only has the bzr revid, then this will cause us to show a tag as
1329
# updated that hasn't actually been updated.
1331
# FIXME: Check for diverged branches
1332
for ref, (git_sha, revid) in viewitems(new_refs):
1333
if ref_equals(ret, ref, git_sha, revid):
1334
# Already up to date
1336
git_sha = old_refs[ref][0]
1338
revid = old_refs[ref][1]
1339
ret[ref] = new_refs[ref] = (git_sha, revid)
1340
elif ref not in ret or overwrite:
1342
tag_name = ref_to_tag_name(ref)
1346
result.tag_updates[tag_name] = revid
1347
ret[ref] = (git_sha, revid)
1349
# FIXME: Check diverged
1353
name = ref_to_tag_name(ref)
1357
result.tag_conflicts.append(
1358
(name, revid, ret[name][1]))
1360
ret[ref] = (git_sha, revid)
1363
def fetch(self, stop_revision=None, fetch_tags=None, lossy=False,
1365
if stop_revision is None:
1366
stop_revision = self.source.last_revision()
1369
for k, v in viewitems(self.source.tags.get_tag_dict()):
1370
ret.append((None, v))
1371
ret.append((None, stop_revision))
1373
self.interrepo.fetch_objects(ret, lossy=lossy, limit=limit)
1374
except NoPushSupport:
1375
raise errors.NoRoundtrippingSupport(self.source, self.target)
1377
def pull(self, overwrite=False, stop_revision=None, local=False,
1378
possible_transports=None, run_hooks=True, _stop_revno=None):
1379
result = GitBranchPullResult()
1380
result.source_branch = self.source
1381
result.target_branch = self.target
1382
with self.source.lock_read(), self.target.lock_write():
1383
new_refs, main_ref, stop_revinfo = self._get_new_refs(
1384
stop_revision, stop_revno=_stop_revno)
1386
def update_refs(old_refs):
1387
return self._update_refs(result, old_refs, new_refs, overwrite)
1389
result.revidmap, old_refs, new_refs = (
1390
self.interrepo.fetch_refs(update_refs, lossy=False))
1391
except NoPushSupport:
1392
raise errors.NoRoundtrippingSupport(self.source, self.target)
1393
(old_sha1, result.old_revid) = old_refs.get(
1394
main_ref, (ZERO_SHA, NULL_REVISION))
1395
if result.old_revid is None:
1396
result.old_revid = self.target.lookup_foreign_revision_id(
1398
result.new_revid = new_refs[main_ref][1]
1399
result.local_branch = None
1400
result.master_branch = self.target
1402
for hook in branch.Branch.hooks['post_pull']:
1406
def push(self, overwrite=False, stop_revision=None, lossy=False,
1407
_override_hook_source_branch=None, _stop_revno=None):
1408
result = GitBranchPushResult()
1409
result.source_branch = self.source
1410
result.target_branch = self.target
1411
result.local_branch = None
1412
result.master_branch = result.target_branch
1413
with self.source.lock_read(), self.target.lock_write():
1414
new_refs, main_ref, stop_revinfo = self._get_new_refs(
1415
stop_revision, stop_revno=_stop_revno)
1417
def update_refs(old_refs):
1418
return self._update_refs(result, old_refs, new_refs, overwrite)
1420
result.revidmap, old_refs, new_refs = (
1421
self.interrepo.fetch_refs(
1422
update_refs, lossy=lossy, overwrite=overwrite))
1423
except NoPushSupport:
1424
raise errors.NoRoundtrippingSupport(self.source, self.target)
1425
(old_sha1, result.old_revid) = old_refs.get(
1426
main_ref, (ZERO_SHA, NULL_REVISION))
1427
if result.old_revid is None:
1428
result.old_revid = self.target.lookup_foreign_revision_id(
1430
result.new_revid = new_refs[main_ref][1]
1431
(result.new_original_revno,
1432
result.new_original_revid) = stop_revinfo
1433
for hook in branch.Branch.hooks['post_push']:
1438
branch.InterBranch.register_optimiser(InterGitLocalGitBranch)
1439
branch.InterBranch.register_optimiser(InterFromGitBranch)
1440
branch.InterBranch.register_optimiser(InterToGitBranch)
1441
branch.InterBranch.register_optimiser(InterLocalGitRemoteGitBranch)
added
removed
breezy/git/branch.py
