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.config import (
26
ConfigFile as GitConfigFile,
30
from dulwich.objects import (
34
from dulwich.repo import check_ref_format
43
repository as _mod_repository,
49
from ..foreign import ForeignBranch
50
from ..revision import (
53
from ..sixish import (
82
remote_refs_dict_to_tag_refs,
85
from .unpeel_map import (
94
def _calculate_revnos(branch):
95
if branch._format.stores_revno():
97
config = branch.get_config_stack()
98
return config.get('calculate_revnos')
101
class GitPullResult(branch.PullResult):
102
"""Result of a pull from a Git branch."""
104
def _lookup_revno(self, revid):
105
if not isinstance(revid, bytes):
106
raise TypeError(revid)
107
if not _calculate_revnos(self.target_branch):
109
# Try in source branch first, it'll be faster
110
with self.target_branch.lock_read():
111
return self.target_branch.revision_id_to_revno(revid)
115
return self._lookup_revno(self.old_revid)
119
return self._lookup_revno(self.new_revid)
122
class InterTagsFromGitToRemoteGit(InterTags):
125
def is_compatible(klass, source, target):
126
if not isinstance(source, GitTags):
128
if not isinstance(target, GitTags):
130
if getattr(target.branch.repository, "_git", None) is not None:
134
def merge(self, overwrite=False, ignore_master=False, selector=None):
135
if self.source.branch.repository.has_same_location(self.target.branch.repository):
139
source_tag_refs = self.source.branch.get_tag_refs()
141
def get_changed_refs(old_refs):
143
for ref_name, tag_name, peeled, unpeeled in (
144
source_tag_refs.iteritems()):
145
if selector and not selector(tag_name):
147
if old_refs.get(ref_name) == unpeeled:
149
elif overwrite or ref_name not in old_refs:
150
ret[ref_name] = unpeeled
151
updates[tag_name] = self.target.branch.repository.lookup_foreign_revision_id(
153
self.target.branch._tag_refs = None
157
self.repository.lookup_foreign_revision_id(peeled),
158
self.target.branch.repository.lookup_foreign_revision_id(
159
old_refs[ref_name])))
161
self.target.branch.repository.controldir.send_pack(
162
get_changed_refs, lambda have, want: [])
163
return updates, set(conflicts)
166
class InterTagsFromGitToLocalGit(InterTags):
169
def is_compatible(klass, source, target):
170
if not isinstance(source, GitTags):
172
if not isinstance(target, GitTags):
174
if getattr(target.branch.repository, "_git", None) is None:
178
def merge(self, overwrite=False, ignore_master=False, selector=None):
179
if self.source.branch.repository.has_same_location(self.target.branch.repository):
184
source_tag_refs = self.source.branch.get_tag_refs()
186
target_repo = self.target.branch.repository
188
for ref_name, tag_name, peeled, unpeeled in source_tag_refs:
189
if selector and not selector(tag_name):
191
if target_repo._git.refs.get(ref_name) == unpeeled:
193
elif overwrite or ref_name not in target_repo._git.refs:
195
updates[tag_name] = (
196
target_repo.lookup_foreign_revision_id(peeled))
198
trace.warning('%s does not point to a valid object',
201
except NotCommitError:
202
trace.warning('%s points to a non-commit object',
205
target_repo._git.refs[ref_name] = unpeeled or peeled
206
self.target.branch._tag_refs = None
209
source_revid = self.source.branch.repository.lookup_foreign_revision_id(
211
target_revid = target_repo.lookup_foreign_revision_id(
212
target_repo._git.refs[ref_name])
214
trace.warning('%s does not point to a valid object',
217
except NotCommitError:
218
trace.warning('%s points to a non-commit object',
221
conflicts.append((tag_name, source_revid, target_revid))
222
return updates, set(conflicts)
225
class InterTagsFromGitToNonGit(InterTags):
228
def is_compatible(klass, source, target):
229
if not isinstance(source, GitTags):
231
if isinstance(target, GitTags):
235
def merge(self, overwrite=False, ignore_master=False, selector=None):
236
"""See Tags.merge_to."""
237
source_tag_refs = self.source.branch.get_tag_refs()
241
master = self.target.branch.get_master_branch()
242
with cleanup.ExitStack() as es:
243
if master is not None:
244
es.enter_context(master.lock_write())
245
updates, conflicts = self._merge_to(
246
self.target, source_tag_refs, overwrite=overwrite,
248
if master is not None:
249
extra_updates, extra_conflicts = self._merge_to(
250
master.tags, overwrite=overwrite,
251
source_tag_refs=source_tag_refs,
252
ignore_master=ignore_master, selector=selector)
253
updates.update(extra_updates)
254
conflicts.update(extra_conflicts)
255
return updates, conflicts
257
def _merge_to(self, to_tags, source_tag_refs, overwrite=False,
259
unpeeled_map = defaultdict(set)
262
result = dict(to_tags.get_tag_dict())
263
for ref_name, tag_name, peeled, unpeeled in source_tag_refs:
264
if selector and not selector(tag_name):
266
if unpeeled is not None:
267
unpeeled_map[peeled].add(unpeeled)
269
bzr_revid = self.source.branch.lookup_foreign_revision_id(peeled)
270
except NotCommitError:
272
if result.get(tag_name) == bzr_revid:
274
elif tag_name not in result or overwrite:
275
result[tag_name] = bzr_revid
276
updates[tag_name] = bzr_revid
278
conflicts.append((tag_name, bzr_revid, result[tag_name]))
279
to_tags._set_tag_dict(result)
280
if len(unpeeled_map) > 0:
281
map_file = UnpeelMap.from_repository(to_tags.branch.repository)
282
map_file.update(unpeeled_map)
283
map_file.save_in_repository(to_tags.branch.repository)
284
return updates, set(conflicts)
287
InterTags.register_optimiser(InterTagsFromGitToRemoteGit)
288
InterTags.register_optimiser(InterTagsFromGitToLocalGit)
289
InterTags.register_optimiser(InterTagsFromGitToNonGit)
293
"""Ref-based tag dictionary."""
295
def __init__(self, branch):
297
self.repository = branch.repository
299
def get_tag_dict(self):
301
for (ref_name, tag_name, peeled, unpeeled) in (
302
self.branch.get_tag_refs()):
304
bzr_revid = self.branch.lookup_foreign_revision_id(peeled)
305
except NotCommitError:
308
ret[tag_name] = bzr_revid
311
def lookup_tag(self, tag_name):
312
"""Return the referent string of a tag"""
313
# TODO(jelmer): Replace with something more efficient for local tags.
314
td = self.get_tag_dict()
318
raise errors.NoSuchTag(tag_name)
321
class LocalGitTagDict(GitTags):
322
"""Dictionary with tags in a local repository."""
324
def __init__(self, branch):
325
super(LocalGitTagDict, self).__init__(branch)
326
self.refs = self.repository.controldir._git.refs
328
def _set_tag_dict(self, to_dict):
329
extra = set(self.refs.allkeys())
330
for k, revid in viewitems(to_dict):
331
name = tag_name_to_ref(k)
335
self.set_tag(k, revid)
336
except errors.GhostTagsNotSupported:
340
del self.repository._git[name]
342
def set_tag(self, name, revid):
344
git_sha, mapping = self.branch.lookup_bzr_revision_id(revid)
345
except errors.NoSuchRevision:
346
raise errors.GhostTagsNotSupported(self)
347
self.refs[tag_name_to_ref(name)] = git_sha
348
self.branch._tag_refs = None
350
def delete_tag(self, name):
351
ref = tag_name_to_ref(name)
352
if ref not in self.refs:
353
raise errors.NoSuchTag(name)
355
self.branch._tag_refs = None
358
class GitBranchFormat(branch.BranchFormat):
360
def network_name(self):
363
def supports_tags(self):
366
def supports_leaving_lock(self):
369
def supports_tags_referencing_ghosts(self):
372
def tags_are_versioned(self):
375
def get_foreign_tests_branch_factory(self):
376
from .tests.test_branch import ForeignTestsBranchFactory
377
return ForeignTestsBranchFactory()
379
def make_tags(self, branch):
382
except AttributeError:
384
if getattr(branch.repository, "_git", None) is None:
385
from .remote import RemoteGitTagDict
386
return RemoteGitTagDict(branch)
388
return LocalGitTagDict(branch)
390
def initialize(self, a_controldir, name=None, repository=None,
391
append_revisions_only=None):
392
raise NotImplementedError(self.initialize)
394
def get_reference(self, controldir, name=None):
395
return controldir.get_branch_reference(name=name)
397
def set_reference(self, controldir, name, target):
398
return controldir.set_branch_reference(target, name)
400
def stores_revno(self):
401
"""True if this branch format store revision numbers."""
404
supports_reference_locations = False
407
class LocalGitBranchFormat(GitBranchFormat):
409
def get_format_description(self):
410
return 'Local Git Branch'
413
def _matchingcontroldir(self):
414
from .dir import LocalGitControlDirFormat
415
return LocalGitControlDirFormat()
417
def initialize(self, a_controldir, name=None, repository=None,
418
append_revisions_only=None):
419
from .dir import LocalGitDir
420
if not isinstance(a_controldir, LocalGitDir):
421
raise errors.IncompatibleFormat(self, a_controldir._format)
422
return a_controldir.create_branch(
423
repository=repository, name=name,
424
append_revisions_only=append_revisions_only)
427
class GitBranch(ForeignBranch):
428
"""An adapter to git repositories for bzr Branch objects."""
431
def control_transport(self):
432
return self._control_transport
435
def user_transport(self):
436
return self._user_transport
438
def __init__(self, controldir, repository, ref, format):
439
self.repository = repository
440
self._format = format
441
self.controldir = controldir
442
self._lock_mode = None
444
super(GitBranch, self).__init__(repository.get_mapping())
447
self._user_transport = controldir.user_transport.clone('.')
448
self._control_transport = controldir.control_transport.clone('.')
449
self._tag_refs = None
452
self.name = ref_to_branch_name(ref)
455
if self.ref is not None:
456
params = {"ref": urlutils.escape(self.ref)}
459
params = {"branch": urlutils.escape(self.name)}
460
for k, v in params.items():
461
self._user_transport.set_segment_parameter(k, v)
462
self._control_transport.set_segment_parameter(k, v)
463
self.base = controldir.user_transport.base
465
def _get_checkout_format(self, lightweight=False):
466
"""Return the most suitable metadir for a checkout of this branch.
467
Weaves are used if this branch's repository uses weaves.
470
return controldir.format_registry.make_controldir("git")
472
return controldir.format_registry.make_controldir("default")
474
def get_child_submit_format(self):
475
"""Return the preferred format of submissions to this branch."""
476
ret = self.get_config_stack().get("child_submit_format")
481
def get_config(self):
482
return GitBranchConfig(self)
484
def get_config_stack(self):
485
return GitBranchStack(self)
487
def _get_nick(self, local=False, possible_master_transports=None):
488
"""Find the nick name for this branch.
492
if getattr(self.repository, '_git', None):
493
cs = self.repository._git.get_config_stack()
495
return cs.get((b"branch", self.name.encode('utf-8')),
496
b"nick").decode("utf-8")
499
return self.name or u"HEAD"
501
def _set_nick(self, nick):
502
cf = self.repository._git.get_config()
503
cf.set((b"branch", self.name.encode('utf-8')),
504
b"nick", nick.encode("utf-8"))
507
self.repository._git._put_named_file('config', f.getvalue())
509
nick = property(_get_nick, _set_nick)
512
return "<%s(%r, %r)>" % (self.__class__.__name__, self.repository.base,
515
def generate_revision_history(self, revid, last_rev=None,
517
if last_rev is not None:
518
graph = self.repository.get_graph()
519
if not graph.is_ancestor(last_rev, revid):
520
# our previous tip is not merged into stop_revision
521
raise errors.DivergedBranches(self, other_branch)
523
self.set_last_revision(revid)
525
def lock_write(self, token=None):
526
if token is not None:
527
raise errors.TokenLockingNotSupported(self)
529
if self._lock_mode == 'r':
530
raise errors.ReadOnlyError(self)
531
self._lock_count += 1
534
self._lock_mode = 'w'
536
self.repository.lock_write()
537
return lock.LogicalLockResult(self.unlock)
539
def leave_lock_in_place(self):
540
raise NotImplementedError(self.leave_lock_in_place)
542
def dont_leave_lock_in_place(self):
543
raise NotImplementedError(self.dont_leave_lock_in_place)
545
def get_stacked_on_url(self):
546
# Git doesn't do stacking (yet...)
547
raise branch.UnstackableBranchFormat(self._format, self.base)
549
def _get_push_origin(self, cs):
550
"""Get the name for the push origin.
552
The exact behaviour is documented in the git-config(1) manpage.
555
return cs.get((b'branch', self.name.encode('utf-8')), b'pushRemote')
558
return cs.get((b'branch', ), b'remote')
561
return cs.get((b'branch', self.name.encode('utf-8')), b'remote')
565
def _get_origin(self, cs):
567
return cs.get((b'branch', self.name.encode('utf-8')), b'remote')
571
def _get_related_push_branch(self, cs):
572
remote = self._get_push_origin(cs)
574
location = cs.get((b"remote", remote), b"url")
578
return git_url_to_bzr_url(location.decode('utf-8'), ref=self.ref)
580
def _get_related_merge_branch(self, cs):
581
remote = self._get_origin(cs)
583
location = cs.get((b"remote", remote), b"url")
588
ref = cs.get((b"branch", remote), b"merge")
592
return git_url_to_bzr_url(location.decode('utf-8'), ref=ref)
594
def _get_parent_location(self):
595
"""See Branch.get_parent()."""
596
cs = self.repository._git.get_config_stack()
597
return self._get_related_merge_branch(cs)
599
def _write_git_config(self, cs):
602
self.repository._git._put_named_file('config', f.getvalue())
604
def set_parent(self, location):
605
cs = self.repository._git.get_config()
606
remote = self._get_origin(cs)
607
this_url = urlutils.strip_segment_parameters(self.user_url)
608
target_url, branch, ref = bzr_url_to_git_url(location)
609
location = urlutils.relative_url(this_url, target_url)
610
cs.set((b"remote", remote), b"url", location)
612
cs.set((b"branch", remote), b"merge", branch_name_to_ref(branch))
614
cs.set((b"branch", remote), b"merge", ref)
616
# TODO(jelmer): Maybe unset rather than setting to HEAD?
617
cs.set((b"branch", remote), b"merge", b'HEAD')
618
self._write_git_config(cs)
620
def break_lock(self):
621
raise NotImplementedError(self.break_lock)
625
if self._lock_mode not in ('r', 'w'):
626
raise ValueError(self._lock_mode)
627
self._lock_count += 1
629
self._lock_mode = 'r'
631
self.repository.lock_read()
632
return lock.LogicalLockResult(self.unlock)
634
def peek_lock_mode(self):
635
return self._lock_mode
638
return (self._lock_mode is not None)
643
def _unlock_ref(self):
647
"""See Branch.unlock()."""
648
if self._lock_count == 0:
649
raise errors.LockNotHeld(self)
651
self._lock_count -= 1
652
if self._lock_count == 0:
653
if self._lock_mode == 'w':
655
self._lock_mode = None
656
self._clear_cached_state()
658
self.repository.unlock()
660
def get_physical_lock_status(self):
663
def last_revision(self):
664
with self.lock_read():
665
# perhaps should escape this ?
666
if self.head is None:
667
return revision.NULL_REVISION
668
return self.lookup_foreign_revision_id(self.head)
670
def _basic_push(self, target, overwrite=False, stop_revision=None,
672
return branch.InterBranch.get(self, target)._basic_push(
673
overwrite, stop_revision, tag_selector=tag_selector)
675
def lookup_foreign_revision_id(self, foreign_revid):
677
return self.repository.lookup_foreign_revision_id(foreign_revid,
681
return self.mapping.revision_id_foreign_to_bzr(foreign_revid)
683
def lookup_bzr_revision_id(self, revid):
684
return self.repository.lookup_bzr_revision_id(
685
revid, mapping=self.mapping)
687
def get_unshelver(self, tree):
688
raise errors.StoringUncommittedNotSupported(self)
690
def _clear_cached_state(self):
691
super(GitBranch, self)._clear_cached_state()
692
self._tag_refs = None
694
def _iter_tag_refs(self, refs):
695
"""Iterate over the tag refs.
697
:param refs: Refs dictionary (name -> git sha1)
698
:return: iterator over (ref_name, tag_name, peeled_sha1, unpeeled_sha1)
700
raise NotImplementedError(self._iter_tag_refs)
702
def get_tag_refs(self):
703
with self.lock_read():
704
if self._tag_refs is None:
705
self._tag_refs = list(self._iter_tag_refs())
706
return self._tag_refs
708
def import_last_revision_info_and_tags(self, source, revno, revid,
710
"""Set the last revision info, importing from another repo if necessary.
712
This is used by the bound branch code to upload a revision to
713
the master branch first before updating the tip of the local branch.
714
Revisions referenced by source's tags are also transferred.
716
:param source: Source branch to optionally fetch from
717
:param revno: Revision number of the new tip
718
:param revid: Revision id of the new tip
719
:param lossy: Whether to discard metadata that can not be
721
:return: Tuple with the new revision number and revision id
722
(should only be different from the arguments when lossy=True)
724
push_result = source.push(
725
self, stop_revision=revid, lossy=lossy, _stop_revno=revno)
726
return (push_result.new_revno, push_result.new_revid)
728
def reconcile(self, thorough=True):
729
"""Make sure the data stored in this branch is consistent."""
730
from ..reconcile import ReconcileResult
732
return ReconcileResult()
735
class LocalGitBranch(GitBranch):
736
"""A local Git branch."""
738
def __init__(self, controldir, repository, ref):
739
super(LocalGitBranch, self).__init__(controldir, repository, ref,
740
LocalGitBranchFormat())
742
def create_checkout(self, to_location, revision_id=None, lightweight=False,
743
accelerator_tree=None, hardlink=False):
744
t = transport.get_transport(to_location)
746
format = self._get_checkout_format(lightweight=lightweight)
747
checkout = format.initialize_on_transport(t)
749
from_branch = checkout.set_branch_reference(target_branch=self)
751
policy = checkout.determine_repository_policy()
752
policy.acquire_repository()
753
checkout_branch = checkout.create_branch()
754
checkout_branch.bind(self)
755
checkout_branch.pull(self, stop_revision=revision_id)
757
return checkout.create_workingtree(
758
revision_id, from_branch=from_branch, hardlink=hardlink)
761
self._ref_lock = self.repository._git.refs.lock_ref(self.ref)
763
def _unlock_ref(self):
764
self._ref_lock.unlock()
766
def break_lock(self):
767
self.repository._git.refs.unlock_ref(self.ref)
769
def _gen_revision_history(self):
770
if self.head is None:
772
last_revid = self.last_revision()
773
graph = self.repository.get_graph()
775
ret = list(graph.iter_lefthand_ancestry(
776
last_revid, (revision.NULL_REVISION, )))
777
except errors.RevisionNotPresent as e:
778
raise errors.GhostRevisionsHaveNoRevno(last_revid, e.revision_id)
784
return self.repository._git.refs[self.ref]
788
def _read_last_revision_info(self):
789
last_revid = self.last_revision()
790
graph = self.repository.get_graph()
792
revno = graph.find_distance_to_null(
793
last_revid, [(revision.NULL_REVISION, 0)])
794
except errors.GhostRevisionsHaveNoRevno:
796
return revno, last_revid
798
def set_last_revision_info(self, revno, revision_id):
799
self.set_last_revision(revision_id)
800
self._last_revision_info_cache = revno, revision_id
802
def set_last_revision(self, revid):
803
if not revid or not isinstance(revid, bytes):
804
raise errors.InvalidRevisionId(revision_id=revid, branch=self)
805
if revid == NULL_REVISION:
808
(newhead, self.mapping) = self.repository.lookup_bzr_revision_id(
810
if self.mapping is None:
812
self._set_head(newhead)
814
def _set_head(self, value):
815
if value == ZERO_SHA:
816
raise ValueError(value)
819
del self.repository._git.refs[self.ref]
821
self.repository._git.refs[self.ref] = self._head
822
self._clear_cached_state()
824
head = property(_get_head, _set_head)
826
def get_push_location(self):
827
"""See Branch.get_push_location."""
828
push_loc = self.get_config_stack().get('push_location')
829
if push_loc is not None:
831
cs = self.repository._git.get_config_stack()
832
return self._get_related_push_branch(cs)
834
def set_push_location(self, location):
835
"""See Branch.set_push_location."""
836
self.get_config().set_user_option('push_location', location,
837
store=config.STORE_LOCATION)
839
def supports_tags(self):
842
def store_uncommitted(self, creator):
843
raise errors.StoringUncommittedNotSupported(self)
845
def _iter_tag_refs(self):
846
"""Iterate over the tag refs.
848
:param refs: Refs dictionary (name -> git sha1)
849
:return: iterator over (ref_name, tag_name, peeled_sha1, unpeeled_sha1)
851
refs = self.repository.controldir.get_refs_container()
852
for ref_name, unpeeled in viewitems(refs.as_dict()):
854
tag_name = ref_to_tag_name(ref_name)
855
except (ValueError, UnicodeDecodeError):
857
peeled = refs.get_peeled(ref_name)
860
if not isinstance(tag_name, text_type):
861
raise TypeError(tag_name)
862
yield (ref_name, tag_name, peeled, unpeeled)
864
def create_memorytree(self):
865
from .memorytree import GitMemoryTree
866
return GitMemoryTree(self, self.repository._git.object_store,
870
def _quick_lookup_revno(local_branch, remote_branch, revid):
871
if not isinstance(revid, bytes):
872
raise TypeError(revid)
873
# Try in source branch first, it'll be faster
874
with local_branch.lock_read():
875
if not _calculate_revnos(local_branch):
878
return local_branch.revision_id_to_revno(revid)
879
except errors.NoSuchRevision:
880
graph = local_branch.repository.get_graph()
882
return graph.find_distance_to_null(
883
revid, [(revision.NULL_REVISION, 0)])
884
except errors.GhostRevisionsHaveNoRevno:
885
if not _calculate_revnos(remote_branch):
887
# FIXME: Check using graph.find_distance_to_null() ?
888
with remote_branch.lock_read():
889
return remote_branch.revision_id_to_revno(revid)
892
class GitBranchPullResult(branch.PullResult):
895
super(GitBranchPullResult, self).__init__()
896
self.new_git_head = None
897
self._old_revno = None
898
self._new_revno = None
900
def report(self, to_file):
902
if self.old_revid == self.new_revid:
903
to_file.write('No revisions to pull.\n')
904
elif self.new_git_head is not None:
905
to_file.write('Now on revision %d (git sha: %s).\n' %
906
(self.new_revno, self.new_git_head))
908
to_file.write('Now on revision %d.\n' % (self.new_revno,))
909
self._show_tag_conficts(to_file)
911
def _lookup_revno(self, revid):
912
return _quick_lookup_revno(self.target_branch, self.source_branch,
915
def _get_old_revno(self):
916
if self._old_revno is not None:
917
return self._old_revno
918
return self._lookup_revno(self.old_revid)
920
def _set_old_revno(self, revno):
921
self._old_revno = revno
923
old_revno = property(_get_old_revno, _set_old_revno)
925
def _get_new_revno(self):
926
if self._new_revno is not None:
927
return self._new_revno
928
return self._lookup_revno(self.new_revid)
930
def _set_new_revno(self, revno):
931
self._new_revno = revno
933
new_revno = property(_get_new_revno, _set_new_revno)
936
class GitBranchPushResult(branch.BranchPushResult):
938
def _lookup_revno(self, revid):
939
return _quick_lookup_revno(self.source_branch, self.target_branch,
944
return self._lookup_revno(self.old_revid)
948
new_original_revno = getattr(self, "new_original_revno", None)
949
if new_original_revno:
950
return new_original_revno
951
if getattr(self, "new_original_revid", None) is not None:
952
return self._lookup_revno(self.new_original_revid)
953
return self._lookup_revno(self.new_revid)
956
class InterFromGitBranch(branch.GenericInterBranch):
957
"""InterBranch implementation that pulls from Git into bzr."""
960
def _get_branch_formats_to_test():
962
default_format = branch.format_registry.get_default()
963
except AttributeError:
964
default_format = branch.BranchFormat._default_format
965
from .remote import RemoteGitBranchFormat
967
(RemoteGitBranchFormat(), default_format),
968
(LocalGitBranchFormat(), default_format)]
971
def _get_interrepo(self, source, target):
972
return _mod_repository.InterRepository.get(
973
source.repository, target.repository)
976
def is_compatible(cls, source, target):
977
if not isinstance(source, GitBranch):
979
if isinstance(target, GitBranch):
980
# InterLocalGitRemoteGitBranch or InterToGitBranch should be used
982
if (getattr(cls._get_interrepo(source, target), "fetch_objects", None)
984
# fetch_objects is necessary for this to work
988
def fetch(self, stop_revision=None, fetch_tags=None, limit=None, lossy=False):
990
stop_revision, fetch_tags=fetch_tags, limit=limit, lossy=lossy)
991
return _mod_repository.FetchResult()
993
def fetch_objects(self, stop_revision, fetch_tags, limit=None, lossy=False, tag_selector=None):
994
interrepo = self._get_interrepo(self.source, self.target)
995
if fetch_tags is None:
996
c = self.source.get_config_stack()
997
fetch_tags = c.get('branch.fetch_tags')
999
def determine_wants(heads):
1000
if stop_revision is None:
1002
head = heads[self.source.ref]
1004
self._last_revid = revision.NULL_REVISION
1006
self._last_revid = self.source.lookup_foreign_revision_id(
1009
self._last_revid = stop_revision
1010
real = interrepo.get_determine_wants_revids(
1011
[self._last_revid], include_tags=fetch_tags, tag_selector=tag_selector)
1013
pack_hint, head, refs = interrepo.fetch_objects(
1014
determine_wants, self.source.mapping, limit=limit,
1016
if (pack_hint is not None and
1017
self.target.repository._format.pack_compresses):
1018
self.target.repository.pack(hint=pack_hint)
1021
def _update_revisions(self, stop_revision=None, overwrite=False, tag_selector=None):
1022
head, refs = self.fetch_objects(stop_revision, fetch_tags=None, tag_selector=tag_selector)
1024
prev_last_revid = None
1026
prev_last_revid = self.target.last_revision()
1027
self.target.generate_revision_history(
1028
self._last_revid, last_rev=prev_last_revid,
1029
other_branch=self.source)
1032
def update_references(self, revid=None):
1034
revid = self.target.last_revision()
1035
tree = self.target.repository.revision_tree(revid)
1037
with tree.get_file('.gitmodules') as f:
1038
for path, url, section in parse_submodules(
1039
GitConfigFile.from_file(f)):
1040
self.target.set_reference_info(
1041
tree.path2id(path.decode('utf-8')), url.decode('utf-8'),
1042
path.decode('utf-8'))
1043
except errors.NoSuchFile:
1046
def _basic_pull(self, stop_revision, overwrite, run_hooks,
1047
_override_hook_target, _hook_master, tag_selector=None):
1048
if overwrite is True:
1049
overwrite = set(["history", "tags"])
1052
result = GitBranchPullResult()
1053
result.source_branch = self.source
1054
if _override_hook_target is None:
1055
result.target_branch = self.target
1057
result.target_branch = _override_hook_target
1058
with self.target.lock_write(), self.source.lock_read():
1059
# We assume that during 'pull' the target repository is closer than
1061
(result.old_revno, result.old_revid) = \
1062
self.target.last_revision_info()
1063
result.new_git_head, remote_refs = self._update_revisions(
1064
stop_revision, overwrite=("history" in overwrite),
1065
tag_selector=tag_selector)
1066
tags_ret = self.source.tags.merge_to(
1067
self.target.tags, ("tags" in overwrite), ignore_master=True)
1068
if isinstance(tags_ret, tuple):
1069
result.tag_updates, result.tag_conflicts = tags_ret
1071
result.tag_conflicts = tags_ret
1072
(result.new_revno, result.new_revid) = \
1073
self.target.last_revision_info()
1074
self.update_references(revid=result.new_revid)
1076
result.master_branch = _hook_master
1077
result.local_branch = result.target_branch
1079
result.master_branch = result.target_branch
1080
result.local_branch = None
1082
for hook in branch.Branch.hooks['post_pull']:
1086
def pull(self, overwrite=False, stop_revision=None,
1087
possible_transports=None, _hook_master=None, run_hooks=True,
1088
_override_hook_target=None, local=False, tag_selector=None):
1091
:param _hook_master: Private parameter - set the branch to
1092
be supplied as the master to pull hooks.
1093
:param run_hooks: Private parameter - if false, this branch
1094
is being called because it's the master of the primary branch,
1095
so it should not run its hooks.
1096
:param _override_hook_target: Private parameter - set the branch to be
1097
supplied as the target_branch to pull hooks.
1099
# This type of branch can't be bound.
1100
bound_location = self.target.get_bound_location()
1101
if local and not bound_location:
1102
raise errors.LocalRequiresBoundBranch()
1103
source_is_master = False
1104
with cleanup.ExitStack() as es:
1105
es.enter_context(self.source.lock_read())
1107
# bound_location comes from a config file, some care has to be
1108
# taken to relate it to source.user_url
1109
normalized = urlutils.normalize_url(bound_location)
1111
relpath = self.source.user_transport.relpath(normalized)
1112
source_is_master = (relpath == '')
1113
except (errors.PathNotChild, urlutils.InvalidURL):
1114
source_is_master = False
1115
if not local and bound_location and not source_is_master:
1116
# not pulling from master, so we need to update master.
1117
master_branch = self.target.get_master_branch(possible_transports)
1118
es.enter_context(master_branch.lock_write())
1119
# pull from source into master.
1120
master_branch.pull(self.source, overwrite, stop_revision,
1123
master_branch = None
1124
return self._basic_pull(stop_revision, overwrite, run_hooks,
1125
_override_hook_target,
1126
_hook_master=master_branch,
1127
tag_selector=tag_selector)
1129
def _basic_push(self, overwrite, stop_revision, tag_selector=None):
1130
if overwrite is True:
1131
overwrite = set(["history", "tags"])
1134
result = branch.BranchPushResult()
1135
result.source_branch = self.source
1136
result.target_branch = self.target
1137
result.old_revno, result.old_revid = self.target.last_revision_info()
1138
result.new_git_head, remote_refs = self._update_revisions(
1139
stop_revision, overwrite=("history" in overwrite),
1140
tag_selector=tag_selector)
1141
tags_ret = self.source.tags.merge_to(
1142
self.target.tags, "tags" in overwrite, ignore_master=True,
1143
selector=tag_selector)
1144
(result.tag_updates, result.tag_conflicts) = tags_ret
1145
result.new_revno, result.new_revid = self.target.last_revision_info()
1146
self.update_references(revid=result.new_revid)
1150
class InterGitBranch(branch.GenericInterBranch):
1151
"""InterBranch implementation that pulls between Git branches."""
1153
def fetch(self, stop_revision=None, fetch_tags=None, limit=None, lossy=False):
1154
raise NotImplementedError(self.fetch)
1157
class InterLocalGitRemoteGitBranch(InterGitBranch):
1158
"""InterBranch that copies from a local to a remote git branch."""
1161
def _get_branch_formats_to_test():
1162
from .remote import RemoteGitBranchFormat
1164
(LocalGitBranchFormat(), RemoteGitBranchFormat())]
1167
def is_compatible(self, source, target):
1168
from .remote import RemoteGitBranch
1169
return (isinstance(source, LocalGitBranch) and
1170
isinstance(target, RemoteGitBranch))
1172
def _basic_push(self, overwrite, stop_revision, tag_selector=None):
1173
result = GitBranchPushResult()
1174
result.source_branch = self.source
1175
result.target_branch = self.target
1176
if stop_revision is None:
1177
stop_revision = self.source.last_revision()
1179
def get_changed_refs(old_refs):
1180
old_ref = old_refs.get(self.target.ref, None)
1182
result.old_revid = revision.NULL_REVISION
1184
result.old_revid = self.target.lookup_foreign_revision_id(
1186
new_ref = self.source.repository.lookup_bzr_revision_id(
1189
if remote_divergence(
1191
self.source.repository._git.object_store):
1192
raise errors.DivergedBranches(self.source, self.target)
1193
refs = {self.target.ref: new_ref}
1194
result.new_revid = stop_revision
1195
for name, sha in viewitems(
1196
self.source.repository._git.refs.as_dict(b"refs/tags")):
1197
if tag_selector and not tag_selector(name):
1199
if sha not in self.source.repository._git:
1200
trace.mutter('Ignoring missing SHA: %s', sha)
1202
refs[tag_name_to_ref(name)] = sha
1204
self.target.repository.send_pack(
1206
self.source.repository._git.object_store.generate_pack_data)
1210
class InterGitLocalGitBranch(InterGitBranch):
1211
"""InterBranch that copies from a remote to a local git branch."""
1214
def _get_branch_formats_to_test():
1215
from .remote import RemoteGitBranchFormat
1217
(RemoteGitBranchFormat(), LocalGitBranchFormat()),
1218
(LocalGitBranchFormat(), LocalGitBranchFormat())]
1221
def is_compatible(self, source, target):
1222
return (isinstance(source, GitBranch) and
1223
isinstance(target, LocalGitBranch))
1225
def fetch(self, stop_revision=None, fetch_tags=None, limit=None, lossy=False):
1226
interrepo = _mod_repository.InterRepository.get(
1227
self.source.repository, self.target.repository)
1228
if stop_revision is None:
1229
stop_revision = self.source.last_revision()
1230
if fetch_tags is None:
1231
c = self.source.get_config_stack()
1232
fetch_tags = c.get('branch.fetch_tags')
1233
determine_wants = interrepo.get_determine_wants_revids(
1234
[stop_revision], include_tags=fetch_tags)
1235
interrepo.fetch_objects(determine_wants, limit=limit, lossy=lossy)
1236
return _mod_repository.FetchResult()
1238
def _basic_push(self, overwrite=False, stop_revision=None, tag_selector=None):
1239
if overwrite is True:
1240
overwrite = set(["history", "tags"])
1243
result = GitBranchPushResult()
1244
result.source_branch = self.source
1245
result.target_branch = self.target
1246
result.old_revid = self.target.last_revision()
1247
refs, stop_revision = self.update_refs(stop_revision)
1248
self.target.generate_revision_history(
1250
(result.old_revid if ("history" not in overwrite) else None),
1251
other_branch=self.source)
1252
tags_ret = self.source.tags.merge_to(
1254
overwrite=("tags" in overwrite),
1255
selector=tag_selector)
1256
if isinstance(tags_ret, tuple):
1257
(result.tag_updates, result.tag_conflicts) = tags_ret
1259
result.tag_conflicts = tags_ret
1260
result.new_revid = self.target.last_revision()
1263
def update_refs(self, stop_revision=None):
1264
interrepo = _mod_repository.InterRepository.get(
1265
self.source.repository, self.target.repository)
1266
c = self.source.get_config_stack()
1267
fetch_tags = c.get('branch.fetch_tags')
1269
if stop_revision is None:
1270
result = interrepo.fetch(branches=[self.source.ref], include_tags=fetch_tags)
1272
head = result.refs[self.source.ref]
1274
stop_revision = revision.NULL_REVISION
1276
stop_revision = self.target.lookup_foreign_revision_id(head)
1278
result = interrepo.fetch(
1279
revision_id=stop_revision, include_tags=fetch_tags)
1280
return result.refs, stop_revision
1282
def pull(self, stop_revision=None, overwrite=False,
1283
possible_transports=None, run_hooks=True, local=False,
1285
# This type of branch can't be bound.
1287
raise errors.LocalRequiresBoundBranch()
1288
if overwrite is True:
1289
overwrite = set(["history", "tags"])
1293
result = GitPullResult()
1294
result.source_branch = self.source
1295
result.target_branch = self.target
1296
with self.target.lock_write(), self.source.lock_read():
1297
result.old_revid = self.target.last_revision()
1298
refs, stop_revision = self.update_refs(stop_revision)
1299
self.target.generate_revision_history(
1301
(result.old_revid if ("history" not in overwrite) else None),
1302
other_branch=self.source)
1303
tags_ret = self.source.tags.merge_to(
1304
self.target.tags, overwrite=("tags" in overwrite),
1305
selector=tag_selector)
1306
if isinstance(tags_ret, tuple):
1307
(result.tag_updates, result.tag_conflicts) = tags_ret
1309
result.tag_conflicts = tags_ret
1310
result.new_revid = self.target.last_revision()
1311
result.local_branch = None
1312
result.master_branch = result.target_branch
1314
for hook in branch.Branch.hooks['post_pull']:
1319
class InterToGitBranch(branch.GenericInterBranch):
1320
"""InterBranch implementation that pulls into a Git branch."""
1322
def __init__(self, source, target):
1323
super(InterToGitBranch, self).__init__(source, target)
1324
self.interrepo = _mod_repository.InterRepository.get(source.repository,
1328
def _get_branch_formats_to_test():
1330
default_format = branch.format_registry.get_default()
1331
except AttributeError:
1332
default_format = branch.BranchFormat._default_format
1333
from .remote import RemoteGitBranchFormat
1335
(default_format, LocalGitBranchFormat()),
1336
(default_format, RemoteGitBranchFormat())]
1339
def is_compatible(self, source, target):
1340
return (not isinstance(source, GitBranch) and
1341
isinstance(target, GitBranch))
1343
def _get_new_refs(self, stop_revision=None, fetch_tags=None,
1345
if not self.source.is_locked():
1346
raise errors.ObjectNotLocked(self.source)
1347
if stop_revision is None:
1348
(stop_revno, stop_revision) = self.source.last_revision_info()
1349
elif stop_revno is None:
1351
stop_revno = self.source.revision_id_to_revno(stop_revision)
1352
except errors.NoSuchRevision:
1354
if not isinstance(stop_revision, bytes):
1355
raise TypeError(stop_revision)
1356
main_ref = self.target.ref
1357
refs = {main_ref: (None, stop_revision)}
1358
if fetch_tags is None:
1359
c = self.source.get_config_stack()
1360
fetch_tags = c.get('branch.fetch_tags')
1361
for name, revid in viewitems(self.source.tags.get_tag_dict()):
1362
if self.source.repository.has_revision(revid):
1363
ref = tag_name_to_ref(name)
1364
if not check_ref_format(ref):
1365
warning("skipping tag with invalid characters %s (%s)",
1369
# FIXME: Skip tags that are not in the ancestry
1370
refs[ref] = (None, revid)
1371
return refs, main_ref, (stop_revno, stop_revision)
1373
def _update_refs(self, result, old_refs, new_refs, overwrite, tag_selector):
1374
mutter("updating refs. old refs: %r, new refs: %r",
1376
result.tag_updates = {}
1377
result.tag_conflicts = []
1378
ret = dict(old_refs)
1380
def ref_equals(refs, ref, git_sha, revid):
1385
if (value[0] is not None and
1386
git_sha is not None and
1387
value[0] == git_sha):
1389
if (value[1] is not None and
1390
revid is not None and
1393
# FIXME: If one side only has the git sha available and the other
1394
# only has the bzr revid, then this will cause us to show a tag as
1395
# updated that hasn't actually been updated.
1397
# FIXME: Check for diverged branches
1398
for ref, (git_sha, revid) in viewitems(new_refs):
1399
if ref_equals(ret, ref, git_sha, revid):
1400
# Already up to date
1402
git_sha = old_refs[ref][0]
1404
revid = old_refs[ref][1]
1405
ret[ref] = new_refs[ref] = (git_sha, revid)
1406
elif ref not in ret or overwrite:
1408
tag_name = ref_to_tag_name(ref)
1412
if tag_selector and not tag_selector(tag_name):
1414
result.tag_updates[tag_name] = revid
1415
ret[ref] = (git_sha, revid)
1417
# FIXME: Check diverged
1421
name = ref_to_tag_name(ref)
1425
result.tag_conflicts.append(
1426
(name, revid, ret[name][1]))
1428
ret[ref] = (git_sha, revid)
1431
def fetch(self, stop_revision=None, fetch_tags=None, lossy=False,
1433
if stop_revision is None:
1434
stop_revision = self.source.last_revision()
1437
for k, v in viewitems(self.source.tags.get_tag_dict()):
1438
ret.append((None, v))
1439
ret.append((None, stop_revision))
1441
revidmap = self.interrepo.fetch_objects(ret, lossy=lossy, limit=limit)
1442
except NoPushSupport:
1443
raise errors.NoRoundtrippingSupport(self.source, self.target)
1444
return _mod_repository.FetchResult(revidmap={
1445
old_revid: new_revid
1446
for (old_revid, (new_sha, new_revid)) in revidmap.items()})
1448
def pull(self, overwrite=False, stop_revision=None, local=False,
1449
possible_transports=None, run_hooks=True, _stop_revno=None,
1451
result = GitBranchPullResult()
1452
result.source_branch = self.source
1453
result.target_branch = self.target
1454
with self.source.lock_read(), self.target.lock_write():
1455
new_refs, main_ref, stop_revinfo = self._get_new_refs(
1456
stop_revision, stop_revno=_stop_revno)
1458
def update_refs(old_refs):
1459
return self._update_refs(result, old_refs, new_refs, overwrite, tag_selector)
1461
result.revidmap, old_refs, new_refs = (
1462
self.interrepo.fetch_refs(update_refs, lossy=False))
1463
except NoPushSupport:
1464
raise errors.NoRoundtrippingSupport(self.source, self.target)
1465
(old_sha1, result.old_revid) = old_refs.get(
1466
main_ref, (ZERO_SHA, NULL_REVISION))
1467
if result.old_revid is None:
1468
result.old_revid = self.target.lookup_foreign_revision_id(
1470
result.new_revid = new_refs[main_ref][1]
1471
result.local_branch = None
1472
result.master_branch = self.target
1474
for hook in branch.Branch.hooks['post_pull']:
1478
def push(self, overwrite=False, stop_revision=None, lossy=False,
1479
_override_hook_source_branch=None, _stop_revno=None,
1481
result = GitBranchPushResult()
1482
result.source_branch = self.source
1483
result.target_branch = self.target
1484
result.local_branch = None
1485
result.master_branch = result.target_branch
1486
with self.source.lock_read(), self.target.lock_write():
1487
new_refs, main_ref, stop_revinfo = self._get_new_refs(
1488
stop_revision, stop_revno=_stop_revno)
1490
def update_refs(old_refs):
1491
return self._update_refs(result, old_refs, new_refs, overwrite, tag_selector)
1493
result.revidmap, old_refs, new_refs = (
1494
self.interrepo.fetch_refs(
1495
update_refs, lossy=lossy, overwrite=overwrite))
1496
except NoPushSupport:
1497
raise errors.NoRoundtrippingSupport(self.source, self.target)
1498
(old_sha1, result.old_revid) = old_refs.get(
1499
main_ref, (ZERO_SHA, NULL_REVISION))
1500
if lossy or result.old_revid is None:
1501
result.old_revid = self.target.lookup_foreign_revision_id(
1503
result.new_revid = new_refs[main_ref][1]
1504
(result.new_original_revno,
1505
result.new_original_revid) = stop_revinfo
1506
for hook in branch.Branch.hooks['post_push']:
1511
branch.InterBranch.register_optimiser(InterGitLocalGitBranch)
1512
branch.InterBranch.register_optimiser(InterFromGitBranch)
1513
branch.InterBranch.register_optimiser(InterToGitBranch)
1514
branch.InterBranch.register_optimiser(InterLocalGitRemoteGitBranch)
added
removed
breezy/git/branch.py
