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
class GitPullResult(branch.PullResult):
86
"""Result of a pull from a Git branch."""
88
def _lookup_revno(self, revid):
89
if not isinstance(revid, bytes):
90
raise TypeError(revid)
91
# Try in source branch first, it'll be faster
92
with self.target_branch.lock_read():
93
return self.target_branch.revision_id_to_revno(revid)
97
return self._lookup_revno(self.old_revid)
101
return self._lookup_revno(self.new_revid)
104
class GitTags(tag.BasicTags):
105
"""Ref-based tag dictionary."""
107
def __init__(self, branch):
109
self.repository = branch.repository
111
def _merge_to_remote_git(self, target_repo, source_tag_refs,
116
def get_changed_refs(old_refs):
118
for ref_name, tag_name, peeled, unpeeled in (
119
source_tag_refs.iteritems()):
120
if old_refs.get(ref_name) == unpeeled:
122
elif overwrite or ref_name not in old_refs:
123
ret[ref_name] = unpeeled
124
updates[tag_name] = target_repo.lookup_foreign_revision_id(
129
self.repository.lookup_foreign_revision_id(peeled),
130
target_repo.lookup_foreign_revision_id(
131
old_refs[ref_name])))
133
target_repo.controldir.send_pack(
134
get_changed_refs, lambda have, want: [])
135
return updates, conflicts
137
def _merge_to_local_git(self, target_repo, source_tag_refs,
141
for ref_name, tag_name, peeled, unpeeled in source_tag_refs:
142
if target_repo._git.refs.get(ref_name) == unpeeled:
144
elif overwrite or ref_name not in target_repo._git.refs:
146
updates[tag_name] = (
147
target_repo.lookup_foreign_revision_id(peeled))
149
trace.warning('%s does not point to a valid object',
152
target_repo._git.refs[ref_name] = unpeeled or peeled
155
source_revid = self.repository.lookup_foreign_revision_id(
157
target_revid = target_repo.lookup_foreign_revision_id(
158
target_repo._git.refs[ref_name])
160
trace.warning('%s does not point to a valid object',
163
conflicts.append((tag_name, source_revid, target_revid))
164
return updates, conflicts
166
def _merge_to_git(self, to_tags, source_tag_refs, overwrite=False):
167
target_repo = to_tags.repository
168
if self.repository.has_same_location(target_repo):
171
if getattr(target_repo, "_git", None):
172
return self._merge_to_local_git(
173
target_repo, source_tag_refs, overwrite)
175
return self._merge_to_remote_git(
176
target_repo, source_tag_refs, overwrite)
178
to_tags.branch._tag_refs = None
180
def _merge_to_non_git(self, to_tags, source_tag_refs, overwrite=False):
181
unpeeled_map = defaultdict(set)
184
result = dict(to_tags.get_tag_dict())
185
for ref_name, tag_name, peeled, unpeeled in source_tag_refs:
186
if unpeeled is not None:
187
unpeeled_map[peeled].add(unpeeled)
189
bzr_revid = self.branch.lookup_foreign_revision_id(peeled)
190
except NotCommitError:
192
if result.get(tag_name) == bzr_revid:
194
elif tag_name not in result or overwrite:
195
result[tag_name] = bzr_revid
196
updates[tag_name] = bzr_revid
198
conflicts.append((tag_name, bzr_revid, result[tag_name]))
199
to_tags._set_tag_dict(result)
200
if len(unpeeled_map) > 0:
201
map_file = UnpeelMap.from_repository(to_tags.branch.repository)
202
map_file.update(unpeeled_map)
203
map_file.save_in_repository(to_tags.branch.repository)
204
return updates, conflicts
206
def merge_to(self, to_tags, overwrite=False, ignore_master=False,
207
source_tag_refs=None):
208
"""See Tags.merge_to."""
209
if source_tag_refs is None:
210
source_tag_refs = self.branch.get_tag_refs()
213
if isinstance(to_tags, GitTags):
214
return self._merge_to_git(to_tags, source_tag_refs,
220
master = to_tags.branch.get_master_branch()
221
if master is not None:
224
updates, conflicts = self._merge_to_non_git(
225
to_tags, source_tag_refs, overwrite=overwrite)
226
if master is not None:
227
extra_updates, extra_conflicts = self.merge_to(
228
master.tags, overwrite=overwrite,
229
source_tag_refs=source_tag_refs,
230
ignore_master=ignore_master)
231
updates.update(extra_updates)
232
conflicts += extra_conflicts
233
return updates, conflicts
235
if master is not None:
238
def get_tag_dict(self):
240
for (ref_name, tag_name, peeled, unpeeled) in (
241
self.branch.get_tag_refs()):
243
bzr_revid = self.branch.lookup_foreign_revision_id(peeled)
244
except NotCommitError:
247
ret[tag_name] = bzr_revid
251
class LocalGitTagDict(GitTags):
252
"""Dictionary with tags in a local repository."""
254
def __init__(self, branch):
255
super(LocalGitTagDict, self).__init__(branch)
256
self.refs = self.repository.controldir._git.refs
258
def _set_tag_dict(self, to_dict):
259
extra = set(self.refs.allkeys())
260
for k, revid in viewitems(to_dict):
261
name = tag_name_to_ref(k)
264
self.set_tag(k, revid)
267
del self.repository._git[name]
269
def set_tag(self, name, revid):
271
git_sha, mapping = self.branch.lookup_bzr_revision_id(revid)
272
except errors.NoSuchRevision:
273
raise errors.GhostTagsNotSupported(self)
274
self.refs[tag_name_to_ref(name)] = git_sha
275
self.branch._tag_refs = None
277
def delete_tag(self, name):
278
ref = tag_name_to_ref(name)
279
if ref not in self.refs:
280
raise errors.NoSuchTag(name)
282
self.branch._tag_refs = None
285
class GitBranchFormat(branch.BranchFormat):
287
def network_name(self):
290
def supports_tags(self):
293
def supports_leaving_lock(self):
296
def supports_tags_referencing_ghosts(self):
299
def tags_are_versioned(self):
302
def get_foreign_tests_branch_factory(self):
303
from .tests.test_branch import ForeignTestsBranchFactory
304
return ForeignTestsBranchFactory()
306
def make_tags(self, branch):
309
except AttributeError:
311
if getattr(branch.repository, "_git", None) is None:
312
from .remote import RemoteGitTagDict
313
return RemoteGitTagDict(branch)
315
return LocalGitTagDict(branch)
317
def initialize(self, a_controldir, name=None, repository=None,
318
append_revisions_only=None):
319
raise NotImplementedError(self.initialize)
321
def get_reference(self, controldir, name=None):
322
return controldir.get_branch_reference(name=name)
324
def set_reference(self, controldir, name, target):
325
return controldir.set_branch_reference(target, name)
328
class LocalGitBranchFormat(GitBranchFormat):
330
def get_format_description(self):
331
return 'Local Git Branch'
334
def _matchingcontroldir(self):
335
from .dir import LocalGitControlDirFormat
336
return LocalGitControlDirFormat()
338
def initialize(self, a_controldir, name=None, repository=None,
339
append_revisions_only=None):
340
from .dir import LocalGitDir
341
if not isinstance(a_controldir, LocalGitDir):
342
raise errors.IncompatibleFormat(self, a_controldir._format)
343
return a_controldir.create_branch(
344
repository=repository, name=name,
345
append_revisions_only=append_revisions_only)
348
class GitBranch(ForeignBranch):
349
"""An adapter to git repositories for bzr Branch objects."""
352
def control_transport(self):
353
return self._control_transport
356
def user_transport(self):
357
return self._user_transport
359
def __init__(self, controldir, repository, ref, format):
360
self.repository = repository
361
self._format = format
362
self.controldir = controldir
363
self._lock_mode = None
365
super(GitBranch, self).__init__(repository.get_mapping())
368
self._user_transport = controldir.user_transport.clone('.')
369
self._control_transport = controldir.control_transport.clone('.')
370
self._tag_refs = None
373
self.name = ref_to_branch_name(ref)
376
if self.ref is not None:
377
params = {"ref": urlutils.escape(self.ref)}
380
params = {"branch": urlutils.escape(self.name)}
381
for k, v in params.items():
382
self._user_transport.set_segment_parameter(k, v)
383
self._control_transport.set_segment_parameter(k, v)
384
self.base = controldir.user_transport.base
386
def _get_checkout_format(self, lightweight=False):
387
"""Return the most suitable metadir for a checkout of this branch.
388
Weaves are used if this branch's repository uses weaves.
391
return controldir.format_registry.make_controldir("git")
393
return controldir.format_registry.make_controldir("default")
395
def get_child_submit_format(self):
396
"""Return the preferred format of submissions to this branch."""
397
ret = self.get_config_stack().get("child_submit_format")
402
def get_config(self):
403
return GitBranchConfig(self)
405
def get_config_stack(self):
406
return GitBranchStack(self)
408
def _get_nick(self, local=False, possible_master_transports=None):
409
"""Find the nick name for this branch.
413
if getattr(self.repository, '_git', None):
414
cs = self.repository._git.get_config_stack()
416
return cs.get((b"branch", self.name.encode('utf-8')),
417
b"nick").decode("utf-8")
420
return self.name or u"HEAD"
422
def _set_nick(self, nick):
423
cf = self.repository._git.get_config()
424
cf.set((b"branch", self.name.encode('utf-8')),
425
b"nick", nick.encode("utf-8"))
428
self.repository._git._put_named_file('config', f.getvalue())
430
nick = property(_get_nick, _set_nick)
433
return "<%s(%r, %r)>" % (self.__class__.__name__, self.repository.base,
436
def generate_revision_history(self, revid, last_rev=None,
438
if last_rev is not None:
439
graph = self.repository.get_graph()
440
if not graph.is_ancestor(last_rev, revid):
441
# our previous tip is not merged into stop_revision
442
raise errors.DivergedBranches(self, other_branch)
444
self.set_last_revision(revid)
446
def lock_write(self, token=None):
447
if token is not None:
448
raise errors.TokenLockingNotSupported(self)
450
if self._lock_mode == 'r':
451
raise errors.ReadOnlyError(self)
452
self._lock_count += 1
455
self._lock_mode = 'w'
457
self.repository.lock_write()
458
return lock.LogicalLockResult(self.unlock)
460
def leave_lock_in_place(self):
461
raise NotImplementedError(self.leave_lock_in_place)
463
def dont_leave_lock_in_place(self):
464
raise NotImplementedError(self.dont_leave_lock_in_place)
466
def get_stacked_on_url(self):
467
# Git doesn't do stacking (yet...)
468
raise branch.UnstackableBranchFormat(self._format, self.base)
470
def _get_push_origin(self, cs):
471
"""Get the name for the push origin.
473
The exact behaviour is documented in the git-config(1) manpage.
476
return cs.get((b'branch', self.name.encode('utf-8')), b'pushRemote')
479
return cs.get((b'branch', ), b'remote')
482
return cs.get((b'branch', self.name.encode('utf-8')), b'remote')
486
def _get_origin(self, cs):
488
return cs.get((b'branch', self.name.encode('utf-8')), b'remote')
492
def _get_related_push_branch(self, cs):
493
remote = self._get_push_origin(cs)
495
location = cs.get((b"remote", remote), b"url")
499
return git_url_to_bzr_url(location.decode('utf-8'), ref=self.ref)
501
def _get_related_merge_branch(self, cs):
502
remote = self._get_origin(cs)
504
location = cs.get((b"remote", remote), b"url")
509
ref = cs.get((b"branch", remote), b"merge")
513
return git_url_to_bzr_url(location.decode('utf-8'), ref=ref)
515
def _get_parent_location(self):
516
"""See Branch.get_parent()."""
517
cs = self.repository._git.get_config_stack()
518
return self._get_related_merge_branch(cs)
520
def _write_git_config(self, cs):
523
self.repository._git._put_named_file('config', f.getvalue())
525
def set_parent(self, location):
526
cs = self.repository._git.get_config()
527
remote = self._get_origin(cs)
528
this_url = urlutils.split_segment_parameters(self.user_url)[0]
529
target_url, branch, ref = bzr_url_to_git_url(location)
530
location = urlutils.relative_url(this_url, target_url)
531
cs.set((b"remote", remote), b"url", location)
533
cs.set((b"branch", remote), b"merge", branch_name_to_ref(branch))
535
cs.set((b"branch", remote), b"merge", ref)
537
# TODO(jelmer): Maybe unset rather than setting to HEAD?
538
cs.set((b"branch", remote), b"merge", b'HEAD')
539
self._write_git_config(cs)
541
def break_lock(self):
542
raise NotImplementedError(self.break_lock)
546
if self._lock_mode not in ('r', 'w'):
547
raise ValueError(self._lock_mode)
548
self._lock_count += 1
550
self._lock_mode = 'r'
552
self.repository.lock_read()
553
return lock.LogicalLockResult(self.unlock)
555
def peek_lock_mode(self):
556
return self._lock_mode
559
return (self._lock_mode is not None)
564
def _unlock_ref(self):
568
"""See Branch.unlock()."""
569
if self._lock_count == 0:
570
raise errors.LockNotHeld(self)
572
self._lock_count -= 1
573
if self._lock_count == 0:
574
if self._lock_mode == 'w':
576
self._lock_mode = None
577
self._clear_cached_state()
579
self.repository.unlock()
581
def get_physical_lock_status(self):
584
def last_revision(self):
585
with self.lock_read():
586
# perhaps should escape this ?
587
if self.head is None:
588
return revision.NULL_REVISION
589
return self.lookup_foreign_revision_id(self.head)
591
def _basic_push(self, target, overwrite=False, stop_revision=None):
592
return branch.InterBranch.get(self, target)._basic_push(
593
overwrite, stop_revision)
595
def lookup_foreign_revision_id(self, foreign_revid):
597
return self.repository.lookup_foreign_revision_id(foreign_revid,
601
return self.mapping.revision_id_foreign_to_bzr(foreign_revid)
603
def lookup_bzr_revision_id(self, revid):
604
return self.repository.lookup_bzr_revision_id(
605
revid, mapping=self.mapping)
607
def get_unshelver(self, tree):
608
raise errors.StoringUncommittedNotSupported(self)
610
def _clear_cached_state(self):
611
super(GitBranch, self)._clear_cached_state()
612
self._tag_refs = None
614
def _iter_tag_refs(self, refs):
615
"""Iterate over the tag refs.
617
:param refs: Refs dictionary (name -> git sha1)
618
:return: iterator over (ref_name, tag_name, peeled_sha1, unpeeled_sha1)
620
raise NotImplementedError(self._iter_tag_refs)
622
def get_tag_refs(self):
623
with self.lock_read():
624
if self._tag_refs is None:
625
self._tag_refs = list(self._iter_tag_refs())
626
return self._tag_refs
628
def import_last_revision_info_and_tags(self, source, revno, revid,
630
"""Set the last revision info, importing from another repo if necessary.
632
This is used by the bound branch code to upload a revision to
633
the master branch first before updating the tip of the local branch.
634
Revisions referenced by source's tags are also transferred.
636
:param source: Source branch to optionally fetch from
637
:param revno: Revision number of the new tip
638
:param revid: Revision id of the new tip
639
:param lossy: Whether to discard metadata that can not be
641
:return: Tuple with the new revision number and revision id
642
(should only be different from the arguments when lossy=True)
644
push_result = source.push(
645
self, stop_revision=revid, lossy=lossy, _stop_revno=revno)
646
return (push_result.new_revno, push_result.new_revid)
648
def reconcile(self, thorough=True):
649
"""Make sure the data stored in this branch is consistent."""
650
from ..reconcile import ReconcileResult
652
return ReconcileResult()
655
class LocalGitBranch(GitBranch):
656
"""A local Git branch."""
658
def __init__(self, controldir, repository, ref):
659
super(LocalGitBranch, self).__init__(controldir, repository, ref,
660
LocalGitBranchFormat())
662
def create_checkout(self, to_location, revision_id=None, lightweight=False,
663
accelerator_tree=None, hardlink=False):
664
t = transport.get_transport(to_location)
666
format = self._get_checkout_format(lightweight=lightweight)
667
checkout = format.initialize_on_transport(t)
669
from_branch = checkout.set_branch_reference(target_branch=self)
671
policy = checkout.determine_repository_policy()
672
policy.acquire_repository()
673
checkout_branch = checkout.create_branch()
674
checkout_branch.bind(self)
675
checkout_branch.pull(self, stop_revision=revision_id)
677
return checkout.create_workingtree(
678
revision_id, from_branch=from_branch, hardlink=hardlink)
681
self._ref_lock = self.repository._git.refs.lock_ref(self.ref)
683
def _unlock_ref(self):
684
self._ref_lock.unlock()
686
def break_lock(self):
687
self.repository._git.refs.unlock_ref(self.ref)
689
def fetch(self, from_branch, last_revision=None, limit=None):
690
return branch.InterBranch.get(from_branch, self).fetch(
691
stop_revision=last_revision, limit=limit)
693
def _gen_revision_history(self):
694
if self.head is None:
696
last_revid = self.last_revision()
697
graph = self.repository.get_graph()
699
ret = list(graph.iter_lefthand_ancestry(
700
last_revid, (revision.NULL_REVISION, )))
701
except errors.RevisionNotPresent as e:
702
raise errors.GhostRevisionsHaveNoRevno(last_revid, e.revision_id)
708
return self.repository._git.refs[self.ref]
712
def _read_last_revision_info(self):
713
last_revid = self.last_revision()
714
graph = self.repository.get_graph()
716
revno = graph.find_distance_to_null(
717
last_revid, [(revision.NULL_REVISION, 0)])
718
except errors.GhostRevisionsHaveNoRevno:
720
return revno, last_revid
722
def set_last_revision_info(self, revno, revision_id):
723
self.set_last_revision(revision_id)
724
self._last_revision_info_cache = revno, revision_id
726
def set_last_revision(self, revid):
727
if not revid or not isinstance(revid, bytes):
728
raise errors.InvalidRevisionId(revision_id=revid, branch=self)
729
if revid == NULL_REVISION:
732
(newhead, self.mapping) = self.repository.lookup_bzr_revision_id(
734
if self.mapping is None:
736
self._set_head(newhead)
738
def _set_head(self, value):
739
if value == ZERO_SHA:
740
raise ValueError(value)
743
del self.repository._git.refs[self.ref]
745
self.repository._git.refs[self.ref] = self._head
746
self._clear_cached_state()
748
head = property(_get_head, _set_head)
750
def get_push_location(self):
751
"""See Branch.get_push_location."""
752
push_loc = self.get_config_stack().get('push_location')
753
if push_loc is not None:
755
cs = self.repository._git.get_config_stack()
756
return self._get_related_push_branch(cs)
758
def set_push_location(self, location):
759
"""See Branch.set_push_location."""
760
self.get_config().set_user_option('push_location', location,
761
store=config.STORE_LOCATION)
763
def supports_tags(self):
766
def store_uncommitted(self, creator):
767
raise errors.StoringUncommittedNotSupported(self)
769
def _iter_tag_refs(self):
770
"""Iterate over the tag refs.
772
:param refs: Refs dictionary (name -> git sha1)
773
:return: iterator over (ref_name, tag_name, peeled_sha1, unpeeled_sha1)
775
refs = self.repository._git.refs
776
for ref_name, unpeeled in viewitems(refs.as_dict()):
778
tag_name = ref_to_tag_name(ref_name)
779
except (ValueError, UnicodeDecodeError):
781
peeled = refs.get_peeled(ref_name)
784
if not isinstance(tag_name, text_type):
785
raise TypeError(tag_name)
786
yield (ref_name, tag_name, peeled, unpeeled)
788
def create_memorytree(self):
789
from .memorytree import GitMemoryTree
790
return GitMemoryTree(self, self.repository._git.object_store,
793
def reference_parent(self, path, file_id=None, possible_transports=None):
794
"""Return the parent branch for a tree-reference file_id
796
:param path: The path of the file_id in the tree
797
:param file_id: Optional file_id of the tree reference
798
:return: A branch associated with the file_id
800
# FIXME should provide multiple branches, based on config
801
url = urlutils.join(self.user_url, path)
802
return branch.Branch.open(
804
possible_transports=possible_transports)
807
def _quick_lookup_revno(local_branch, remote_branch, revid):
808
if not isinstance(revid, bytes):
809
raise TypeError(revid)
810
# Try in source branch first, it'll be faster
811
with local_branch.lock_read():
813
return local_branch.revision_id_to_revno(revid)
814
except errors.NoSuchRevision:
815
graph = local_branch.repository.get_graph()
817
return graph.find_distance_to_null(
818
revid, [(revision.NULL_REVISION, 0)])
819
except errors.GhostRevisionsHaveNoRevno:
820
# FIXME: Check using graph.find_distance_to_null() ?
821
with remote_branch.lock_read():
822
return remote_branch.revision_id_to_revno(revid)
825
class GitBranchPullResult(branch.PullResult):
828
super(GitBranchPullResult, self).__init__()
829
self.new_git_head = None
830
self._old_revno = None
831
self._new_revno = None
833
def report(self, to_file):
835
if self.old_revid == self.new_revid:
836
to_file.write('No revisions to pull.\n')
837
elif self.new_git_head is not None:
838
to_file.write('Now on revision %d (git sha: %s).\n' %
839
(self.new_revno, self.new_git_head))
841
to_file.write('Now on revision %d.\n' % (self.new_revno,))
842
self._show_tag_conficts(to_file)
844
def _lookup_revno(self, revid):
845
return _quick_lookup_revno(self.target_branch, self.source_branch,
848
def _get_old_revno(self):
849
if self._old_revno is not None:
850
return self._old_revno
851
return self._lookup_revno(self.old_revid)
853
def _set_old_revno(self, revno):
854
self._old_revno = revno
856
old_revno = property(_get_old_revno, _set_old_revno)
858
def _get_new_revno(self):
859
if self._new_revno is not None:
860
return self._new_revno
861
return self._lookup_revno(self.new_revid)
863
def _set_new_revno(self, revno):
864
self._new_revno = revno
866
new_revno = property(_get_new_revno, _set_new_revno)
869
class GitBranchPushResult(branch.BranchPushResult):
871
def _lookup_revno(self, revid):
872
return _quick_lookup_revno(self.source_branch, self.target_branch,
877
return self._lookup_revno(self.old_revid)
881
new_original_revno = getattr(self, "new_original_revno", None)
882
if new_original_revno:
883
return new_original_revno
884
if getattr(self, "new_original_revid", None) is not None:
885
return self._lookup_revno(self.new_original_revid)
886
return self._lookup_revno(self.new_revid)
889
class InterFromGitBranch(branch.GenericInterBranch):
890
"""InterBranch implementation that pulls from Git into bzr."""
893
def _get_branch_formats_to_test():
895
default_format = branch.format_registry.get_default()
896
except AttributeError:
897
default_format = branch.BranchFormat._default_format
898
from .remote import RemoteGitBranchFormat
900
(RemoteGitBranchFormat(), default_format),
901
(LocalGitBranchFormat(), default_format)]
904
def _get_interrepo(self, source, target):
905
return _mod_repository.InterRepository.get(
906
source.repository, target.repository)
909
def is_compatible(cls, source, target):
910
if not isinstance(source, GitBranch):
912
if isinstance(target, GitBranch):
913
# InterLocalGitRemoteGitBranch or InterToGitBranch should be used
915
if (getattr(cls._get_interrepo(source, target), "fetch_objects", None)
917
# fetch_objects is necessary for this to work
921
def fetch(self, stop_revision=None, fetch_tags=None, limit=None):
922
self.fetch_objects(stop_revision, fetch_tags=fetch_tags, limit=limit)
924
def fetch_objects(self, stop_revision, fetch_tags, limit=None):
925
interrepo = self._get_interrepo(self.source, self.target)
926
if fetch_tags is None:
927
c = self.source.get_config_stack()
928
fetch_tags = c.get('branch.fetch_tags')
930
def determine_wants(heads):
931
if stop_revision is None:
933
head = heads[self.source.ref]
935
self._last_revid = revision.NULL_REVISION
937
self._last_revid = self.source.lookup_foreign_revision_id(
940
self._last_revid = stop_revision
941
real = interrepo.get_determine_wants_revids(
942
[self._last_revid], include_tags=fetch_tags)
944
pack_hint, head, refs = interrepo.fetch_objects(
945
determine_wants, self.source.mapping, limit=limit)
946
if (pack_hint is not None and
947
self.target.repository._format.pack_compresses):
948
self.target.repository.pack(hint=pack_hint)
951
def _update_revisions(self, stop_revision=None, overwrite=False):
952
head, refs = self.fetch_objects(stop_revision, fetch_tags=None)
954
prev_last_revid = None
956
prev_last_revid = self.target.last_revision()
957
self.target.generate_revision_history(
958
self._last_revid, last_rev=prev_last_revid,
959
other_branch=self.source)
962
def _basic_pull(self, stop_revision, overwrite, run_hooks,
963
_override_hook_target, _hook_master):
964
if overwrite is True:
965
overwrite = set(["history", "tags"])
968
result = GitBranchPullResult()
969
result.source_branch = self.source
970
if _override_hook_target is None:
971
result.target_branch = self.target
973
result.target_branch = _override_hook_target
974
with self.target.lock_write(), self.source.lock_read():
975
# We assume that during 'pull' the target repository is closer than
977
(result.old_revno, result.old_revid) = \
978
self.target.last_revision_info()
979
result.new_git_head, remote_refs = self._update_revisions(
980
stop_revision, overwrite=("history" in overwrite))
981
tags_ret = self.source.tags.merge_to(
982
self.target.tags, ("tags" in overwrite), ignore_master=True)
983
if isinstance(tags_ret, tuple):
984
result.tag_updates, result.tag_conflicts = tags_ret
986
result.tag_conflicts = tags_ret
987
(result.new_revno, result.new_revid) = \
988
self.target.last_revision_info()
990
result.master_branch = _hook_master
991
result.local_branch = result.target_branch
993
result.master_branch = result.target_branch
994
result.local_branch = None
996
for hook in branch.Branch.hooks['post_pull']:
1000
def pull(self, overwrite=False, stop_revision=None,
1001
possible_transports=None, _hook_master=None, run_hooks=True,
1002
_override_hook_target=None, local=False):
1005
:param _hook_master: Private parameter - set the branch to
1006
be supplied as the master to pull hooks.
1007
:param run_hooks: Private parameter - if false, this branch
1008
is being called because it's the master of the primary branch,
1009
so it should not run its hooks.
1010
:param _override_hook_target: Private parameter - set the branch to be
1011
supplied as the target_branch to pull hooks.
1013
# This type of branch can't be bound.
1014
bound_location = self.target.get_bound_location()
1015
if local and not bound_location:
1016
raise errors.LocalRequiresBoundBranch()
1017
master_branch = None
1018
source_is_master = False
1019
self.source.lock_read()
1021
# bound_location comes from a config file, some care has to be
1022
# taken to relate it to source.user_url
1023
normalized = urlutils.normalize_url(bound_location)
1025
relpath = self.source.user_transport.relpath(normalized)
1026
source_is_master = (relpath == '')
1027
except (errors.PathNotChild, urlutils.InvalidURL):
1028
source_is_master = False
1029
if not local and bound_location and not source_is_master:
1030
# not pulling from master, so we need to update master.
1031
master_branch = self.target.get_master_branch(possible_transports)
1032
master_branch.lock_write()
1036
# pull from source into master.
1037
master_branch.pull(self.source, overwrite, stop_revision,
1039
result = self._basic_pull(stop_revision, overwrite, run_hooks,
1040
_override_hook_target,
1041
_hook_master=master_branch)
1043
self.source.unlock()
1046
master_branch.unlock()
1049
def _basic_push(self, overwrite, stop_revision):
1050
if overwrite is True:
1051
overwrite = set(["history", "tags"])
1054
result = branch.BranchPushResult()
1055
result.source_branch = self.source
1056
result.target_branch = self.target
1057
result.old_revno, result.old_revid = self.target.last_revision_info()
1058
result.new_git_head, remote_refs = self._update_revisions(
1059
stop_revision, overwrite=("history" in overwrite))
1060
tags_ret = self.source.tags.merge_to(
1061
self.target.tags, "tags" in overwrite, ignore_master=True)
1062
(result.tag_updates, result.tag_conflicts) = tags_ret
1063
result.new_revno, result.new_revid = self.target.last_revision_info()
1067
class InterGitBranch(branch.GenericInterBranch):
1068
"""InterBranch implementation that pulls between Git branches."""
1070
def fetch(self, stop_revision=None, fetch_tags=None, limit=None):
1071
raise NotImplementedError(self.fetch)
1074
class InterLocalGitRemoteGitBranch(InterGitBranch):
1075
"""InterBranch that copies from a local to a remote git branch."""
1078
def _get_branch_formats_to_test():
1079
from .remote import RemoteGitBranchFormat
1081
(LocalGitBranchFormat(), RemoteGitBranchFormat())]
1084
def is_compatible(self, source, target):
1085
from .remote import RemoteGitBranch
1086
return (isinstance(source, LocalGitBranch) and
1087
isinstance(target, RemoteGitBranch))
1089
def _basic_push(self, overwrite, stop_revision):
1090
result = GitBranchPushResult()
1091
result.source_branch = self.source
1092
result.target_branch = self.target
1093
if stop_revision is None:
1094
stop_revision = self.source.last_revision()
1096
def get_changed_refs(old_refs):
1097
old_ref = old_refs.get(self.target.ref, None)
1099
result.old_revid = revision.NULL_REVISION
1101
result.old_revid = self.target.lookup_foreign_revision_id(
1103
new_ref = self.source.repository.lookup_bzr_revision_id(
1106
if remote_divergence(
1108
self.source.repository._git.object_store):
1109
raise errors.DivergedBranches(self.source, self.target)
1110
refs = {self.target.ref: new_ref}
1111
result.new_revid = stop_revision
1112
for name, sha in viewitems(
1113
self.source.repository._git.refs.as_dict(b"refs/tags")):
1114
refs[tag_name_to_ref(name)] = sha
1116
self.target.repository.send_pack(
1118
self.source.repository._git.object_store.generate_pack_data)
1122
class InterGitLocalGitBranch(InterGitBranch):
1123
"""InterBranch that copies from a remote to a local git branch."""
1126
def _get_branch_formats_to_test():
1127
from .remote import RemoteGitBranchFormat
1129
(RemoteGitBranchFormat(), LocalGitBranchFormat()),
1130
(LocalGitBranchFormat(), LocalGitBranchFormat())]
1133
def is_compatible(self, source, target):
1134
return (isinstance(source, GitBranch) and
1135
isinstance(target, LocalGitBranch))
1137
def fetch(self, stop_revision=None, fetch_tags=None, limit=None):
1138
interrepo = _mod_repository.InterRepository.get(self.source.repository,
1139
self.target.repository)
1140
if stop_revision is None:
1141
stop_revision = self.source.last_revision()
1142
determine_wants = interrepo.get_determine_wants_revids(
1143
[stop_revision], include_tags=fetch_tags)
1144
interrepo.fetch_objects(determine_wants, limit=limit)
1146
def _basic_push(self, overwrite=False, stop_revision=None):
1147
if overwrite is True:
1148
overwrite = set(["history", "tags"])
1151
result = GitBranchPushResult()
1152
result.source_branch = self.source
1153
result.target_branch = self.target
1154
result.old_revid = self.target.last_revision()
1155
refs, stop_revision = self.update_refs(stop_revision)
1156
self.target.generate_revision_history(
1158
(result.old_revid if ("history" not in overwrite) else None),
1159
other_branch=self.source)
1160
tags_ret = self.source.tags.merge_to(
1162
source_tag_refs=remote_refs_dict_to_tag_refs(refs),
1163
overwrite=("tags" in overwrite))
1164
if isinstance(tags_ret, tuple):
1165
(result.tag_updates, result.tag_conflicts) = tags_ret
1167
result.tag_conflicts = tags_ret
1168
result.new_revid = self.target.last_revision()
1171
def update_refs(self, stop_revision=None):
1172
interrepo = _mod_repository.InterRepository.get(
1173
self.source.repository, self.target.repository)
1174
c = self.source.get_config_stack()
1175
fetch_tags = c.get('branch.fetch_tags')
1177
if stop_revision is None:
1178
refs = interrepo.fetch(branches=[self.source.ref], include_tags=fetch_tags)
1180
head = refs[self.source.ref]
1182
stop_revision = revision.NULL_REVISION
1184
stop_revision = self.target.lookup_foreign_revision_id(head)
1186
refs = interrepo.fetch(
1187
revision_id=stop_revision, include_tags=fetch_tags)
1188
return refs, stop_revision
1190
def pull(self, stop_revision=None, overwrite=False,
1191
possible_transports=None, run_hooks=True, local=False):
1192
# This type of branch can't be bound.
1194
raise errors.LocalRequiresBoundBranch()
1195
if overwrite is True:
1196
overwrite = set(["history", "tags"])
1200
result = GitPullResult()
1201
result.source_branch = self.source
1202
result.target_branch = self.target
1203
with self.target.lock_write(), self.source.lock_read():
1204
result.old_revid = self.target.last_revision()
1205
refs, stop_revision = self.update_refs(stop_revision)
1206
self.target.generate_revision_history(
1208
(result.old_revid if ("history" not in overwrite) else None),
1209
other_branch=self.source)
1210
tags_ret = self.source.tags.merge_to(
1211
self.target.tags, overwrite=("tags" in overwrite),
1212
source_tag_refs=remote_refs_dict_to_tag_refs(refs))
1213
if isinstance(tags_ret, tuple):
1214
(result.tag_updates, result.tag_conflicts) = tags_ret
1216
result.tag_conflicts = tags_ret
1217
result.new_revid = self.target.last_revision()
1218
result.local_branch = None
1219
result.master_branch = result.target_branch
1221
for hook in branch.Branch.hooks['post_pull']:
1226
class InterToGitBranch(branch.GenericInterBranch):
1227
"""InterBranch implementation that pulls into a Git branch."""
1229
def __init__(self, source, target):
1230
super(InterToGitBranch, self).__init__(source, target)
1231
self.interrepo = _mod_repository.InterRepository.get(source.repository,
1235
def _get_branch_formats_to_test():
1237
default_format = branch.format_registry.get_default()
1238
except AttributeError:
1239
default_format = branch.BranchFormat._default_format
1240
from .remote import RemoteGitBranchFormat
1242
(default_format, LocalGitBranchFormat()),
1243
(default_format, RemoteGitBranchFormat())]
1246
def is_compatible(self, source, target):
1247
return (not isinstance(source, GitBranch) and
1248
isinstance(target, GitBranch))
1250
def _get_new_refs(self, stop_revision=None, fetch_tags=None,
1252
if not self.source.is_locked():
1253
raise errors.ObjectNotLocked(self.source)
1254
if stop_revision is None:
1255
(stop_revno, stop_revision) = self.source.last_revision_info()
1256
elif stop_revno is None:
1258
stop_revno = self.source.revision_id_to_revno(stop_revision)
1259
except errors.NoSuchRevision:
1261
if not isinstance(stop_revision, bytes):
1262
raise TypeError(stop_revision)
1263
main_ref = self.target.ref
1264
refs = {main_ref: (None, stop_revision)}
1265
if fetch_tags is None:
1266
c = self.source.get_config_stack()
1267
fetch_tags = c.get('branch.fetch_tags')
1268
for name, revid in viewitems(self.source.tags.get_tag_dict()):
1269
if self.source.repository.has_revision(revid):
1270
ref = tag_name_to_ref(name)
1271
if not check_ref_format(ref):
1272
warning("skipping tag with invalid characters %s (%s)",
1276
# FIXME: Skip tags that are not in the ancestry
1277
refs[ref] = (None, revid)
1278
return refs, main_ref, (stop_revno, stop_revision)
1280
def _update_refs(self, result, old_refs, new_refs, overwrite):
1281
mutter("updating refs. old refs: %r, new refs: %r",
1283
result.tag_updates = {}
1284
result.tag_conflicts = []
1285
ret = dict(old_refs)
1287
def ref_equals(refs, ref, git_sha, revid):
1292
if (value[0] is not None and
1293
git_sha is not None and
1294
value[0] == git_sha):
1296
if (value[1] is not None and
1297
revid is not None and
1300
# FIXME: If one side only has the git sha available and the other
1301
# only has the bzr revid, then this will cause us to show a tag as
1302
# updated that hasn't actually been updated.
1304
# FIXME: Check for diverged branches
1305
for ref, (git_sha, revid) in viewitems(new_refs):
1306
if ref_equals(ret, ref, git_sha, revid):
1307
# Already up to date
1309
git_sha = old_refs[ref][0]
1311
revid = old_refs[ref][1]
1312
ret[ref] = new_refs[ref] = (git_sha, revid)
1313
elif ref not in ret or overwrite:
1315
tag_name = ref_to_tag_name(ref)
1319
result.tag_updates[tag_name] = revid
1320
ret[ref] = (git_sha, revid)
1322
# FIXME: Check diverged
1326
name = ref_to_tag_name(ref)
1330
result.tag_conflicts.append(
1331
(name, revid, ret[name][1]))
1333
ret[ref] = (git_sha, revid)
1336
def fetch(self, stop_revision=None, fetch_tags=None, lossy=False,
1338
if stop_revision is None:
1339
stop_revision = self.source.last_revision()
1342
for k, v in viewitems(self.source.tags.get_tag_dict()):
1343
ret.append((None, v))
1344
ret.append((None, stop_revision))
1346
self.interrepo.fetch_objects(ret, lossy=lossy, limit=limit)
1347
except NoPushSupport:
1348
raise errors.NoRoundtrippingSupport(self.source, self.target)
1350
def pull(self, overwrite=False, stop_revision=None, local=False,
1351
possible_transports=None, run_hooks=True, _stop_revno=None):
1352
result = GitBranchPullResult()
1353
result.source_branch = self.source
1354
result.target_branch = self.target
1355
with self.source.lock_read(), self.target.lock_write():
1356
new_refs, main_ref, stop_revinfo = self._get_new_refs(
1357
stop_revision, stop_revno=_stop_revno)
1359
def update_refs(old_refs):
1360
return self._update_refs(result, old_refs, new_refs, overwrite)
1362
result.revidmap, old_refs, new_refs = (
1363
self.interrepo.fetch_refs(update_refs, lossy=False))
1364
except NoPushSupport:
1365
raise errors.NoRoundtrippingSupport(self.source, self.target)
1366
(old_sha1, result.old_revid) = old_refs.get(
1367
main_ref, (ZERO_SHA, NULL_REVISION))
1368
if result.old_revid is None:
1369
result.old_revid = self.target.lookup_foreign_revision_id(
1371
result.new_revid = new_refs[main_ref][1]
1372
result.local_branch = None
1373
result.master_branch = self.target
1375
for hook in branch.Branch.hooks['post_pull']:
1379
def push(self, overwrite=False, stop_revision=None, lossy=False,
1380
_override_hook_source_branch=None, _stop_revno=None):
1381
result = GitBranchPushResult()
1382
result.source_branch = self.source
1383
result.target_branch = self.target
1384
result.local_branch = None
1385
result.master_branch = result.target_branch
1386
with self.source.lock_read(), self.target.lock_write():
1387
new_refs, main_ref, stop_revinfo = self._get_new_refs(
1388
stop_revision, stop_revno=_stop_revno)
1390
def update_refs(old_refs):
1391
return self._update_refs(result, old_refs, new_refs, overwrite)
1393
result.revidmap, old_refs, new_refs = (
1394
self.interrepo.fetch_refs(
1395
update_refs, lossy=lossy, overwrite=overwrite))
1396
except NoPushSupport:
1397
raise errors.NoRoundtrippingSupport(self.source, self.target)
1398
(old_sha1, result.old_revid) = old_refs.get(
1399
main_ref, (ZERO_SHA, NULL_REVISION))
1400
if result.old_revid is None:
1401
result.old_revid = self.target.lookup_foreign_revision_id(
1403
result.new_revid = new_refs[main_ref][1]
1404
(result.new_original_revno,
1405
result.new_original_revid) = stop_revinfo
1406
for hook in branch.Branch.hooks['post_push']:
1411
branch.InterBranch.register_optimiser(InterGitLocalGitBranch)
1412
branch.InterBranch.register_optimiser(InterFromGitBranch)
1413
branch.InterBranch.register_optimiser(InterToGitBranch)
1414
branch.InterBranch.register_optimiser(InterLocalGitRemoteGitBranch)
added
removed
breezy/git/branch.py
