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 (
79
from .urls import git_url_to_bzr_url
82
class GitPullResult(branch.PullResult):
83
"""Result of a pull from a Git branch."""
85
def _lookup_revno(self, revid):
86
if not isinstance(revid, bytes):
87
raise TypeError(revid)
88
# Try in source branch first, it'll be faster
89
with self.target_branch.lock_read():
90
return self.target_branch.revision_id_to_revno(revid)
94
return self._lookup_revno(self.old_revid)
98
return self._lookup_revno(self.new_revid)
101
class GitTags(tag.BasicTags):
102
"""Ref-based tag dictionary."""
104
def __init__(self, branch):
106
self.repository = branch.repository
108
def _merge_to_remote_git(self, target_repo, source_tag_refs,
113
def get_changed_refs(old_refs):
115
for ref_name, tag_name, peeled, unpeeled in (
116
source_tag_refs.iteritems()):
117
if old_refs.get(ref_name) == unpeeled:
119
elif overwrite or ref_name not in old_refs:
120
ret[ref_name] = unpeeled
121
updates[tag_name] = target_repo.lookup_foreign_revision_id(
126
self.repository.lookup_foreign_revision_id(peeled),
127
target_repo.lookup_foreign_revision_id(
128
old_refs[ref_name])))
130
target_repo.controldir.send_pack(
131
get_changed_refs, lambda have, want: [])
132
return updates, conflicts
134
def _merge_to_local_git(self, target_repo, source_tag_refs,
138
for ref_name, tag_name, peeled, unpeeled in source_tag_refs:
139
if target_repo._git.refs.get(ref_name) == unpeeled:
141
elif overwrite or ref_name not in target_repo._git.refs:
143
updates[tag_name] = (
144
target_repo.lookup_foreign_revision_id(peeled))
146
trace.warning('%s does not point to a valid object',
149
target_repo._git.refs[ref_name] = unpeeled or peeled
152
source_revid = self.repository.lookup_foreign_revision_id(
154
target_revid = target_repo.lookup_foreign_revision_id(
155
target_repo._git.refs[ref_name])
157
trace.warning('%s does not point to a valid object',
160
conflicts.append((tag_name, source_revid, target_revid))
161
return updates, conflicts
163
def _merge_to_git(self, to_tags, source_tag_refs, overwrite=False):
164
target_repo = to_tags.repository
165
if self.repository.has_same_location(target_repo):
168
if getattr(target_repo, "_git", None):
169
return self._merge_to_local_git(
170
target_repo, source_tag_refs, overwrite)
172
return self._merge_to_remote_git(
173
target_repo, source_tag_refs, overwrite)
175
to_tags.branch._tag_refs = None
177
def _merge_to_non_git(self, to_tags, source_tag_refs, overwrite=False):
178
unpeeled_map = defaultdict(set)
181
result = dict(to_tags.get_tag_dict())
182
for ref_name, tag_name, peeled, unpeeled in source_tag_refs:
183
if unpeeled is not None:
184
unpeeled_map[peeled].add(unpeeled)
186
bzr_revid = self.branch.lookup_foreign_revision_id(peeled)
187
except NotCommitError:
189
if result.get(tag_name) == bzr_revid:
191
elif tag_name not in result or overwrite:
192
result[tag_name] = bzr_revid
193
updates[tag_name] = bzr_revid
195
conflicts.append((tag_name, bzr_revid, result[tag_name]))
196
to_tags._set_tag_dict(result)
197
if len(unpeeled_map) > 0:
198
map_file = UnpeelMap.from_repository(to_tags.branch.repository)
199
map_file.update(unpeeled_map)
200
map_file.save_in_repository(to_tags.branch.repository)
201
return updates, conflicts
203
def merge_to(self, to_tags, overwrite=False, ignore_master=False,
204
source_tag_refs=None):
205
"""See Tags.merge_to."""
206
if source_tag_refs is None:
207
source_tag_refs = self.branch.get_tag_refs()
210
if isinstance(to_tags, GitTags):
211
return self._merge_to_git(to_tags, source_tag_refs,
217
master = to_tags.branch.get_master_branch()
218
if master is not None:
221
updates, conflicts = self._merge_to_non_git(
222
to_tags, source_tag_refs, overwrite=overwrite)
223
if master is not None:
224
extra_updates, extra_conflicts = self.merge_to(
225
master.tags, overwrite=overwrite,
226
source_tag_refs=source_tag_refs,
227
ignore_master=ignore_master)
228
updates.update(extra_updates)
229
conflicts += extra_conflicts
230
return updates, conflicts
232
if master is not None:
235
def get_tag_dict(self):
237
for (ref_name, tag_name, peeled, unpeeled) in (
238
self.branch.get_tag_refs()):
240
bzr_revid = self.branch.lookup_foreign_revision_id(peeled)
241
except NotCommitError:
244
ret[tag_name] = bzr_revid
248
class LocalGitTagDict(GitTags):
249
"""Dictionary with tags in a local repository."""
251
def __init__(self, branch):
252
super(LocalGitTagDict, self).__init__(branch)
253
self.refs = self.repository.controldir._git.refs
255
def _set_tag_dict(self, to_dict):
256
extra = set(self.refs.allkeys())
257
for k, revid in viewitems(to_dict):
258
name = tag_name_to_ref(k)
261
self.set_tag(k, revid)
264
del self.repository._git[name]
266
def set_tag(self, name, revid):
268
git_sha, mapping = self.branch.lookup_bzr_revision_id(revid)
269
except errors.NoSuchRevision:
270
raise errors.GhostTagsNotSupported(self)
271
self.refs[tag_name_to_ref(name)] = git_sha
272
self.branch._tag_refs = None
274
def delete_tag(self, name):
275
ref = tag_name_to_ref(name)
276
if ref not in self.refs:
277
raise errors.NoSuchTag(name)
279
self.branch._tag_refs = None
282
class GitBranchFormat(branch.BranchFormat):
284
def network_name(self):
287
def supports_tags(self):
290
def supports_leaving_lock(self):
293
def supports_tags_referencing_ghosts(self):
296
def tags_are_versioned(self):
299
def get_foreign_tests_branch_factory(self):
300
from .tests.test_branch import ForeignTestsBranchFactory
301
return ForeignTestsBranchFactory()
303
def make_tags(self, branch):
306
except AttributeError:
308
if getattr(branch.repository, "_git", None) is None:
309
from .remote import RemoteGitTagDict
310
return RemoteGitTagDict(branch)
312
return LocalGitTagDict(branch)
314
def initialize(self, a_controldir, name=None, repository=None,
315
append_revisions_only=None):
316
raise NotImplementedError(self.initialize)
318
def get_reference(self, controldir, name=None):
319
return controldir.get_branch_reference(name=name)
321
def set_reference(self, controldir, name, target):
322
return controldir.set_branch_reference(target, name)
325
class LocalGitBranchFormat(GitBranchFormat):
327
def get_format_description(self):
328
return 'Local Git Branch'
331
def _matchingcontroldir(self):
332
from .dir import LocalGitControlDirFormat
333
return LocalGitControlDirFormat()
335
def initialize(self, a_controldir, name=None, repository=None,
336
append_revisions_only=None):
337
from .dir import LocalGitDir
338
if not isinstance(a_controldir, LocalGitDir):
339
raise errors.IncompatibleFormat(self, a_controldir._format)
340
return a_controldir.create_branch(
341
repository=repository, name=name,
342
append_revisions_only=append_revisions_only)
345
class GitBranch(ForeignBranch):
346
"""An adapter to git repositories for bzr Branch objects."""
349
def control_transport(self):
350
return self._control_transport
353
def user_transport(self):
354
return self._user_transport
356
def __init__(self, controldir, repository, ref, format):
357
self.repository = repository
358
self._format = format
359
self.controldir = controldir
360
self._lock_mode = None
362
super(GitBranch, self).__init__(repository.get_mapping())
365
self._user_transport = controldir.user_transport.clone('.')
366
self._control_transport = controldir.control_transport.clone('.')
367
self._tag_refs = None
370
self.name = ref_to_branch_name(ref)
373
if self.ref is not None:
374
params = {"ref": urlutils.escape(self.ref)}
377
params = {"branch": urlutils.escape(self.name)}
378
for k, v in params.items():
379
self._user_transport.set_segment_parameter(k, v)
380
self._control_transport.set_segment_parameter(k, v)
381
self.base = controldir.user_transport.base
383
def _get_checkout_format(self, lightweight=False):
384
"""Return the most suitable metadir for a checkout of this branch.
385
Weaves are used if this branch's repository uses weaves.
388
return controldir.format_registry.make_controldir("git")
390
return controldir.format_registry.make_controldir("default")
392
def get_child_submit_format(self):
393
"""Return the preferred format of submissions to this branch."""
394
ret = self.get_config_stack().get("child_submit_format")
399
def get_config(self):
400
return GitBranchConfig(self)
402
def get_config_stack(self):
403
return GitBranchStack(self)
405
def _get_nick(self, local=False, possible_master_transports=None):
406
"""Find the nick name for this branch.
410
if getattr(self.repository, '_git', None):
411
cs = self.repository._git.get_config_stack()
413
return cs.get((b"branch", self.name.encode('utf-8')),
414
b"nick").decode("utf-8")
417
return self.name or u"HEAD"
419
def _set_nick(self, nick):
420
cf = self.repository._git.get_config()
421
cf.set((b"branch", self.name.encode('utf-8')),
422
b"nick", nick.encode("utf-8"))
425
self.repository._git._put_named_file('config', f.getvalue())
427
nick = property(_get_nick, _set_nick)
430
return "<%s(%r, %r)>" % (self.__class__.__name__, self.repository.base,
433
def generate_revision_history(self, revid, last_rev=None,
435
if last_rev is not None:
436
graph = self.repository.get_graph()
437
if not graph.is_ancestor(last_rev, revid):
438
# our previous tip is not merged into stop_revision
439
raise errors.DivergedBranches(self, other_branch)
441
self.set_last_revision(revid)
443
def lock_write(self, token=None):
444
if token is not None:
445
raise errors.TokenLockingNotSupported(self)
447
if self._lock_mode == 'r':
448
raise errors.ReadOnlyError(self)
449
self._lock_count += 1
452
self._lock_mode = 'w'
454
self.repository.lock_write()
455
return lock.LogicalLockResult(self.unlock)
457
def leave_lock_in_place(self):
458
raise NotImplementedError(self.leave_lock_in_place)
460
def dont_leave_lock_in_place(self):
461
raise NotImplementedError(self.dont_leave_lock_in_place)
463
def get_stacked_on_url(self):
464
# Git doesn't do stacking (yet...)
465
raise branch.UnstackableBranchFormat(self._format, self.base)
467
def _get_parent_location(self):
468
"""See Branch.get_parent()."""
469
# FIXME: Set "origin" url from .git/config ?
470
cs = self.repository._git.get_config_stack()
472
location = cs.get((b"remote", b'origin'), b"url")
478
ref = cs.get((b"remote", b"origin"), b"merge")
484
params['branch'] = urlutils.escape(ref_to_branch_name(ref))
486
params['ref'] = urlutils.quote_from_bytes(ref)
488
url = git_url_to_bzr_url(location.decode('utf-8'))
489
return urlutils.join_segment_parameters(url, params)
491
def set_parent(self, location):
492
# FIXME: Set "origin" url in .git/config ?
493
cs = self.repository._git.get_config()
494
this_url = urlutils.split_segment_parameters(self.user_url)[0]
495
target_url, target_params = urlutils.split_segment_parameters(location)
496
location = urlutils.relative_url(this_url, target_url)
497
cs.set((b"remote", b"origin"), b"url", location)
498
if 'branch' in target_params:
499
cs.set((b"remote", b"origin"), b"merge",
500
branch_name_to_ref(target_params['branch']))
501
elif 'ref' in target_params:
502
cs.set((b"remote", b"origin"), b"merge",
503
target_params['ref'])
505
# TODO(jelmer): Maybe unset rather than setting to HEAD?
506
cs.set((b"remote", b"origin"), b"merge", 'HEAD')
509
self.repository._git._put_named_file('config', f.getvalue())
511
def break_lock(self):
512
raise NotImplementedError(self.break_lock)
516
if self._lock_mode not in ('r', 'w'):
517
raise ValueError(self._lock_mode)
518
self._lock_count += 1
520
self._lock_mode = 'r'
522
self.repository.lock_read()
523
return lock.LogicalLockResult(self.unlock)
525
def peek_lock_mode(self):
526
return self._lock_mode
529
return (self._lock_mode is not None)
534
def _unlock_ref(self):
538
"""See Branch.unlock()."""
539
if self._lock_count == 0:
540
raise errors.LockNotHeld(self)
542
self._lock_count -= 1
543
if self._lock_count == 0:
544
if self._lock_mode == 'w':
546
self._lock_mode = None
547
self._clear_cached_state()
549
self.repository.unlock()
551
def get_physical_lock_status(self):
554
def last_revision(self):
555
with self.lock_read():
556
# perhaps should escape this ?
557
if self.head is None:
558
return revision.NULL_REVISION
559
return self.lookup_foreign_revision_id(self.head)
561
def _basic_push(self, target, overwrite=False, stop_revision=None):
562
return branch.InterBranch.get(self, target)._basic_push(
563
overwrite, stop_revision)
565
def lookup_foreign_revision_id(self, foreign_revid):
567
return self.repository.lookup_foreign_revision_id(foreign_revid,
571
return self.mapping.revision_id_foreign_to_bzr(foreign_revid)
573
def lookup_bzr_revision_id(self, revid):
574
return self.repository.lookup_bzr_revision_id(
575
revid, mapping=self.mapping)
577
def get_unshelver(self, tree):
578
raise errors.StoringUncommittedNotSupported(self)
580
def _clear_cached_state(self):
581
super(GitBranch, self)._clear_cached_state()
582
self._tag_refs = None
584
def _iter_tag_refs(self, refs):
585
"""Iterate over the tag refs.
587
:param refs: Refs dictionary (name -> git sha1)
588
:return: iterator over (ref_name, tag_name, peeled_sha1, unpeeled_sha1)
590
raise NotImplementedError(self._iter_tag_refs)
592
def get_tag_refs(self):
593
with self.lock_read():
594
if self._tag_refs is None:
595
self._tag_refs = list(self._iter_tag_refs())
596
return self._tag_refs
598
def import_last_revision_info_and_tags(self, source, revno, revid,
600
"""Set the last revision info, importing from another repo if necessary.
602
This is used by the bound branch code to upload a revision to
603
the master branch first before updating the tip of the local branch.
604
Revisions referenced by source's tags are also transferred.
606
:param source: Source branch to optionally fetch from
607
:param revno: Revision number of the new tip
608
:param revid: Revision id of the new tip
609
:param lossy: Whether to discard metadata that can not be
611
:return: Tuple with the new revision number and revision id
612
(should only be different from the arguments when lossy=True)
614
push_result = source.push(
615
self, stop_revision=revid, lossy=lossy, _stop_revno=revno)
616
return (push_result.new_revno, push_result.new_revid)
618
def reconcile(self, thorough=True):
619
"""Make sure the data stored in this branch is consistent."""
620
from ..reconcile import ReconcileResult
622
return ReconcileResult()
625
class LocalGitBranch(GitBranch):
626
"""A local Git branch."""
628
def __init__(self, controldir, repository, ref):
629
super(LocalGitBranch, self).__init__(controldir, repository, ref,
630
LocalGitBranchFormat())
632
def create_checkout(self, to_location, revision_id=None, lightweight=False,
633
accelerator_tree=None, hardlink=False):
634
t = transport.get_transport(to_location)
636
format = self._get_checkout_format(lightweight=lightweight)
637
checkout = format.initialize_on_transport(t)
639
from_branch = checkout.set_branch_reference(target_branch=self)
641
policy = checkout.determine_repository_policy()
642
policy.acquire_repository()
643
checkout_branch = checkout.create_branch()
644
checkout_branch.bind(self)
645
checkout_branch.pull(self, stop_revision=revision_id)
647
return checkout.create_workingtree(
648
revision_id, from_branch=from_branch, hardlink=hardlink)
651
self._ref_lock = self.repository._git.refs.lock_ref(self.ref)
653
def _unlock_ref(self):
654
self._ref_lock.unlock()
656
def break_lock(self):
657
self.repository._git.refs.unlock_ref(self.ref)
659
def fetch(self, from_branch, last_revision=None, limit=None):
660
return branch.InterBranch.get(from_branch, self).fetch(
661
stop_revision=last_revision, limit=limit)
663
def _gen_revision_history(self):
664
if self.head is None:
666
last_revid = self.last_revision()
667
graph = self.repository.get_graph()
669
ret = list(graph.iter_lefthand_ancestry(
670
last_revid, (revision.NULL_REVISION, )))
671
except errors.RevisionNotPresent as e:
672
raise errors.GhostRevisionsHaveNoRevno(last_revid, e.revision_id)
678
return self.repository._git.refs[self.ref]
682
def _read_last_revision_info(self):
683
last_revid = self.last_revision()
684
graph = self.repository.get_graph()
686
revno = graph.find_distance_to_null(
687
last_revid, [(revision.NULL_REVISION, 0)])
688
except errors.GhostRevisionsHaveNoRevno:
690
return revno, last_revid
692
def set_last_revision_info(self, revno, revision_id):
693
self.set_last_revision(revision_id)
694
self._last_revision_info_cache = revno, revision_id
696
def set_last_revision(self, revid):
697
if not revid or not isinstance(revid, bytes):
698
raise errors.InvalidRevisionId(revision_id=revid, branch=self)
699
if revid == NULL_REVISION:
702
(newhead, self.mapping) = self.repository.lookup_bzr_revision_id(
704
if self.mapping is None:
706
self._set_head(newhead)
708
def _set_head(self, value):
709
if value == ZERO_SHA:
710
raise ValueError(value)
713
del self.repository._git.refs[self.ref]
715
self.repository._git.refs[self.ref] = self._head
716
self._clear_cached_state()
718
head = property(_get_head, _set_head)
720
def get_push_location(self):
721
"""See Branch.get_push_location."""
722
push_loc = self.get_config_stack().get('push_location')
725
def set_push_location(self, location):
726
"""See Branch.set_push_location."""
727
self.get_config().set_user_option('push_location', location,
728
store=config.STORE_LOCATION)
730
def supports_tags(self):
733
def store_uncommitted(self, creator):
734
raise errors.StoringUncommittedNotSupported(self)
736
def _iter_tag_refs(self):
737
"""Iterate over the tag refs.
739
:param refs: Refs dictionary (name -> git sha1)
740
:return: iterator over (ref_name, tag_name, peeled_sha1, unpeeled_sha1)
742
refs = self.repository._git.refs
743
for ref_name, unpeeled in viewitems(refs.as_dict()):
745
tag_name = ref_to_tag_name(ref_name)
746
except (ValueError, UnicodeDecodeError):
748
peeled = refs.get_peeled(ref_name)
751
if not isinstance(tag_name, text_type):
752
raise TypeError(tag_name)
753
yield (ref_name, tag_name, peeled, unpeeled)
755
def create_memorytree(self):
756
from .memorytree import GitMemoryTree
757
return GitMemoryTree(self, self.repository._git.object_store,
760
def reference_parent(self, path, file_id=None, possible_transports=None):
761
"""Return the parent branch for a tree-reference file_id
763
:param path: The path of the file_id in the tree
764
:param file_id: Optional file_id of the tree reference
765
:return: A branch associated with the file_id
767
# FIXME should provide multiple branches, based on config
768
url = urlutils.join(self.user_url, path)
769
return branch.Branch.open(
771
possible_transports=possible_transports)
774
def _quick_lookup_revno(local_branch, remote_branch, revid):
775
if not isinstance(revid, bytes):
776
raise TypeError(revid)
777
# Try in source branch first, it'll be faster
778
with local_branch.lock_read():
780
return local_branch.revision_id_to_revno(revid)
781
except errors.NoSuchRevision:
782
graph = local_branch.repository.get_graph()
784
return graph.find_distance_to_null(
785
revid, [(revision.NULL_REVISION, 0)])
786
except errors.GhostRevisionsHaveNoRevno:
787
# FIXME: Check using graph.find_distance_to_null() ?
788
with remote_branch.lock_read():
789
return remote_branch.revision_id_to_revno(revid)
792
class GitBranchPullResult(branch.PullResult):
795
super(GitBranchPullResult, self).__init__()
796
self.new_git_head = None
797
self._old_revno = None
798
self._new_revno = None
800
def report(self, to_file):
802
if self.old_revid == self.new_revid:
803
to_file.write('No revisions to pull.\n')
804
elif self.new_git_head is not None:
805
to_file.write('Now on revision %d (git sha: %s).\n' %
806
(self.new_revno, self.new_git_head))
808
to_file.write('Now on revision %d.\n' % (self.new_revno,))
809
self._show_tag_conficts(to_file)
811
def _lookup_revno(self, revid):
812
return _quick_lookup_revno(self.target_branch, self.source_branch,
815
def _get_old_revno(self):
816
if self._old_revno is not None:
817
return self._old_revno
818
return self._lookup_revno(self.old_revid)
820
def _set_old_revno(self, revno):
821
self._old_revno = revno
823
old_revno = property(_get_old_revno, _set_old_revno)
825
def _get_new_revno(self):
826
if self._new_revno is not None:
827
return self._new_revno
828
return self._lookup_revno(self.new_revid)
830
def _set_new_revno(self, revno):
831
self._new_revno = revno
833
new_revno = property(_get_new_revno, _set_new_revno)
836
class GitBranchPushResult(branch.BranchPushResult):
838
def _lookup_revno(self, revid):
839
return _quick_lookup_revno(self.source_branch, self.target_branch,
844
return self._lookup_revno(self.old_revid)
848
new_original_revno = getattr(self, "new_original_revno", None)
849
if new_original_revno:
850
return new_original_revno
851
if getattr(self, "new_original_revid", None) is not None:
852
return self._lookup_revno(self.new_original_revid)
853
return self._lookup_revno(self.new_revid)
856
class InterFromGitBranch(branch.GenericInterBranch):
857
"""InterBranch implementation that pulls from Git into bzr."""
860
def _get_branch_formats_to_test():
862
default_format = branch.format_registry.get_default()
863
except AttributeError:
864
default_format = branch.BranchFormat._default_format
865
from .remote import RemoteGitBranchFormat
867
(RemoteGitBranchFormat(), default_format),
868
(LocalGitBranchFormat(), default_format)]
871
def _get_interrepo(self, source, target):
872
return _mod_repository.InterRepository.get(
873
source.repository, target.repository)
876
def is_compatible(cls, source, target):
877
if not isinstance(source, GitBranch):
879
if isinstance(target, GitBranch):
880
# InterLocalGitRemoteGitBranch or InterToGitBranch should be used
882
if (getattr(cls._get_interrepo(source, target), "fetch_objects", None)
884
# fetch_objects is necessary for this to work
888
def fetch(self, stop_revision=None, fetch_tags=None, limit=None):
889
self.fetch_objects(stop_revision, fetch_tags=fetch_tags, limit=limit)
891
def fetch_objects(self, stop_revision, fetch_tags, limit=None):
892
interrepo = self._get_interrepo(self.source, self.target)
893
if fetch_tags is None:
894
c = self.source.get_config_stack()
895
fetch_tags = c.get('branch.fetch_tags')
897
def determine_wants(heads):
898
if stop_revision is None:
900
head = heads[self.source.ref]
902
self._last_revid = revision.NULL_REVISION
904
self._last_revid = self.source.lookup_foreign_revision_id(
907
self._last_revid = stop_revision
908
real = interrepo.get_determine_wants_revids(
909
[self._last_revid], include_tags=fetch_tags)
911
pack_hint, head, refs = interrepo.fetch_objects(
912
determine_wants, self.source.mapping, limit=limit)
913
if (pack_hint is not None and
914
self.target.repository._format.pack_compresses):
915
self.target.repository.pack(hint=pack_hint)
918
def _update_revisions(self, stop_revision=None, overwrite=False):
919
head, refs = self.fetch_objects(stop_revision, fetch_tags=None)
921
prev_last_revid = None
923
prev_last_revid = self.target.last_revision()
924
self.target.generate_revision_history(
925
self._last_revid, last_rev=prev_last_revid,
926
other_branch=self.source)
929
def _basic_pull(self, stop_revision, overwrite, run_hooks,
930
_override_hook_target, _hook_master):
931
if overwrite is True:
932
overwrite = set(["history", "tags"])
935
result = GitBranchPullResult()
936
result.source_branch = self.source
937
if _override_hook_target is None:
938
result.target_branch = self.target
940
result.target_branch = _override_hook_target
941
with self.target.lock_write(), self.source.lock_read():
942
# We assume that during 'pull' the target repository is closer than
944
(result.old_revno, result.old_revid) = \
945
self.target.last_revision_info()
946
result.new_git_head, remote_refs = self._update_revisions(
947
stop_revision, overwrite=("history" in overwrite))
948
tags_ret = self.source.tags.merge_to(
949
self.target.tags, ("tags" in overwrite), ignore_master=True)
950
if isinstance(tags_ret, tuple):
951
result.tag_updates, result.tag_conflicts = tags_ret
953
result.tag_conflicts = tags_ret
954
(result.new_revno, result.new_revid) = \
955
self.target.last_revision_info()
957
result.master_branch = _hook_master
958
result.local_branch = result.target_branch
960
result.master_branch = result.target_branch
961
result.local_branch = None
963
for hook in branch.Branch.hooks['post_pull']:
967
def pull(self, overwrite=False, stop_revision=None,
968
possible_transports=None, _hook_master=None, run_hooks=True,
969
_override_hook_target=None, local=False):
972
:param _hook_master: Private parameter - set the branch to
973
be supplied as the master to pull hooks.
974
:param run_hooks: Private parameter - if false, this branch
975
is being called because it's the master of the primary branch,
976
so it should not run its hooks.
977
:param _override_hook_target: Private parameter - set the branch to be
978
supplied as the target_branch to pull hooks.
980
# This type of branch can't be bound.
981
bound_location = self.target.get_bound_location()
982
if local and not bound_location:
983
raise errors.LocalRequiresBoundBranch()
985
source_is_master = False
986
self.source.lock_read()
988
# bound_location comes from a config file, some care has to be
989
# taken to relate it to source.user_url
990
normalized = urlutils.normalize_url(bound_location)
992
relpath = self.source.user_transport.relpath(normalized)
993
source_is_master = (relpath == '')
994
except (errors.PathNotChild, urlutils.InvalidURL):
995
source_is_master = False
996
if not local and bound_location and not source_is_master:
997
# not pulling from master, so we need to update master.
998
master_branch = self.target.get_master_branch(possible_transports)
999
master_branch.lock_write()
1003
# pull from source into master.
1004
master_branch.pull(self.source, overwrite, stop_revision,
1006
result = self._basic_pull(stop_revision, overwrite, run_hooks,
1007
_override_hook_target,
1008
_hook_master=master_branch)
1010
self.source.unlock()
1013
master_branch.unlock()
1016
def _basic_push(self, overwrite, stop_revision):
1017
if overwrite is True:
1018
overwrite = set(["history", "tags"])
1021
result = branch.BranchPushResult()
1022
result.source_branch = self.source
1023
result.target_branch = self.target
1024
result.old_revno, result.old_revid = self.target.last_revision_info()
1025
result.new_git_head, remote_refs = self._update_revisions(
1026
stop_revision, overwrite=("history" in overwrite))
1027
tags_ret = self.source.tags.merge_to(
1028
self.target.tags, "tags" in overwrite, ignore_master=True)
1029
(result.tag_updates, result.tag_conflicts) = tags_ret
1030
result.new_revno, result.new_revid = self.target.last_revision_info()
1034
class InterGitBranch(branch.GenericInterBranch):
1035
"""InterBranch implementation that pulls between Git branches."""
1037
def fetch(self, stop_revision=None, fetch_tags=None, limit=None):
1038
raise NotImplementedError(self.fetch)
1041
class InterLocalGitRemoteGitBranch(InterGitBranch):
1042
"""InterBranch that copies from a local to a remote git branch."""
1045
def _get_branch_formats_to_test():
1046
from .remote import RemoteGitBranchFormat
1048
(LocalGitBranchFormat(), RemoteGitBranchFormat())]
1051
def is_compatible(self, source, target):
1052
from .remote import RemoteGitBranch
1053
return (isinstance(source, LocalGitBranch) and
1054
isinstance(target, RemoteGitBranch))
1056
def _basic_push(self, overwrite, stop_revision):
1057
result = GitBranchPushResult()
1058
result.source_branch = self.source
1059
result.target_branch = self.target
1060
if stop_revision is None:
1061
stop_revision = self.source.last_revision()
1063
def get_changed_refs(old_refs):
1064
old_ref = old_refs.get(self.target.ref, None)
1066
result.old_revid = revision.NULL_REVISION
1068
result.old_revid = self.target.lookup_foreign_revision_id(
1070
new_ref = self.source.repository.lookup_bzr_revision_id(
1073
if remote_divergence(
1075
self.source.repository._git.object_store):
1076
raise errors.DivergedBranches(self.source, self.target)
1077
refs = {self.target.ref: new_ref}
1078
result.new_revid = stop_revision
1079
for name, sha in viewitems(
1080
self.source.repository._git.refs.as_dict(b"refs/tags")):
1081
refs[tag_name_to_ref(name)] = sha
1083
self.target.repository.send_pack(
1085
self.source.repository._git.object_store.generate_pack_data)
1089
class InterGitLocalGitBranch(InterGitBranch):
1090
"""InterBranch that copies from a remote to a local git branch."""
1093
def _get_branch_formats_to_test():
1094
from .remote import RemoteGitBranchFormat
1096
(RemoteGitBranchFormat(), LocalGitBranchFormat()),
1097
(LocalGitBranchFormat(), LocalGitBranchFormat())]
1100
def is_compatible(self, source, target):
1101
return (isinstance(source, GitBranch) and
1102
isinstance(target, LocalGitBranch))
1104
def fetch(self, stop_revision=None, fetch_tags=None, limit=None):
1105
interrepo = _mod_repository.InterRepository.get(self.source.repository,
1106
self.target.repository)
1107
if stop_revision is None:
1108
stop_revision = self.source.last_revision()
1109
determine_wants = interrepo.get_determine_wants_revids(
1110
[stop_revision], include_tags=fetch_tags)
1111
interrepo.fetch_objects(determine_wants, limit=limit)
1113
def _basic_push(self, overwrite=False, stop_revision=None):
1114
if overwrite is True:
1115
overwrite = set(["history", "tags"])
1118
result = GitBranchPushResult()
1119
result.source_branch = self.source
1120
result.target_branch = self.target
1121
result.old_revid = self.target.last_revision()
1122
refs, stop_revision = self.update_refs(stop_revision)
1123
self.target.generate_revision_history(
1125
(result.old_revid if ("history" not in overwrite) else None),
1126
other_branch=self.source)
1127
tags_ret = self.source.tags.merge_to(
1129
source_tag_refs=remote_refs_dict_to_tag_refs(refs),
1130
overwrite=("tags" in overwrite))
1131
if isinstance(tags_ret, tuple):
1132
(result.tag_updates, result.tag_conflicts) = tags_ret
1134
result.tag_conflicts = tags_ret
1135
result.new_revid = self.target.last_revision()
1138
def update_refs(self, stop_revision=None):
1139
interrepo = _mod_repository.InterRepository.get(
1140
self.source.repository, self.target.repository)
1141
c = self.source.get_config_stack()
1142
fetch_tags = c.get('branch.fetch_tags')
1144
if stop_revision is None:
1145
refs = interrepo.fetch(branches=[self.source.ref], include_tags=fetch_tags)
1147
head = refs[self.source.ref]
1149
stop_revision = revision.NULL_REVISION
1151
stop_revision = self.target.lookup_foreign_revision_id(head)
1153
refs = interrepo.fetch(
1154
revision_id=stop_revision, include_tags=fetch_tags)
1155
return refs, stop_revision
1157
def pull(self, stop_revision=None, overwrite=False,
1158
possible_transports=None, run_hooks=True, local=False):
1159
# This type of branch can't be bound.
1161
raise errors.LocalRequiresBoundBranch()
1162
if overwrite is True:
1163
overwrite = set(["history", "tags"])
1167
result = GitPullResult()
1168
result.source_branch = self.source
1169
result.target_branch = self.target
1170
with self.target.lock_write(), self.source.lock_read():
1171
result.old_revid = self.target.last_revision()
1172
refs, stop_revision = self.update_refs(stop_revision)
1173
self.target.generate_revision_history(
1175
(result.old_revid if ("history" not in overwrite) else None),
1176
other_branch=self.source)
1177
tags_ret = self.source.tags.merge_to(
1178
self.target.tags, overwrite=("tags" in overwrite),
1179
source_tag_refs=remote_refs_dict_to_tag_refs(refs))
1180
if isinstance(tags_ret, tuple):
1181
(result.tag_updates, result.tag_conflicts) = tags_ret
1183
result.tag_conflicts = tags_ret
1184
result.new_revid = self.target.last_revision()
1185
result.local_branch = None
1186
result.master_branch = result.target_branch
1188
for hook in branch.Branch.hooks['post_pull']:
1193
class InterToGitBranch(branch.GenericInterBranch):
1194
"""InterBranch implementation that pulls into a Git branch."""
1196
def __init__(self, source, target):
1197
super(InterToGitBranch, self).__init__(source, target)
1198
self.interrepo = _mod_repository.InterRepository.get(source.repository,
1202
def _get_branch_formats_to_test():
1204
default_format = branch.format_registry.get_default()
1205
except AttributeError:
1206
default_format = branch.BranchFormat._default_format
1207
from .remote import RemoteGitBranchFormat
1209
(default_format, LocalGitBranchFormat()),
1210
(default_format, RemoteGitBranchFormat())]
1213
def is_compatible(self, source, target):
1214
return (not isinstance(source, GitBranch) and
1215
isinstance(target, GitBranch))
1217
def _get_new_refs(self, stop_revision=None, fetch_tags=None,
1219
if not self.source.is_locked():
1220
raise errors.ObjectNotLocked(self.source)
1221
if stop_revision is None:
1222
(stop_revno, stop_revision) = self.source.last_revision_info()
1223
elif stop_revno is None:
1224
stop_revno = self.source.revision_id_to_revno(stop_revision)
1225
if not isinstance(stop_revision, bytes):
1226
raise TypeError(stop_revision)
1227
main_ref = self.target.ref
1228
refs = {main_ref: (None, stop_revision)}
1229
if fetch_tags is None:
1230
c = self.source.get_config_stack()
1231
fetch_tags = c.get('branch.fetch_tags')
1232
for name, revid in viewitems(self.source.tags.get_tag_dict()):
1233
if self.source.repository.has_revision(revid):
1234
ref = tag_name_to_ref(name)
1235
if not check_ref_format(ref):
1236
warning("skipping tag with invalid characters %s (%s)",
1240
# FIXME: Skip tags that are not in the ancestry
1241
refs[ref] = (None, revid)
1242
return refs, main_ref, (stop_revno, stop_revision)
1244
def _update_refs(self, result, old_refs, new_refs, overwrite):
1245
mutter("updating refs. old refs: %r, new refs: %r",
1247
result.tag_updates = {}
1248
result.tag_conflicts = []
1249
ret = dict(old_refs)
1251
def ref_equals(refs, ref, git_sha, revid):
1256
if (value[0] is not None and
1257
git_sha is not None and
1258
value[0] == git_sha):
1260
if (value[1] is not None and
1261
revid is not None and
1264
# FIXME: If one side only has the git sha available and the other
1265
# only has the bzr revid, then this will cause us to show a tag as
1266
# updated that hasn't actually been updated.
1268
# FIXME: Check for diverged branches
1269
for ref, (git_sha, revid) in viewitems(new_refs):
1270
if ref_equals(ret, ref, git_sha, revid):
1271
# Already up to date
1273
git_sha = old_refs[ref][0]
1275
revid = old_refs[ref][1]
1276
ret[ref] = new_refs[ref] = (git_sha, revid)
1277
elif ref not in ret or overwrite:
1279
tag_name = ref_to_tag_name(ref)
1283
result.tag_updates[tag_name] = revid
1284
ret[ref] = (git_sha, revid)
1286
# FIXME: Check diverged
1290
name = ref_to_tag_name(ref)
1294
result.tag_conflicts.append(
1295
(name, revid, ret[name][1]))
1297
ret[ref] = (git_sha, revid)
1300
def fetch(self, stop_revision=None, fetch_tags=None, lossy=False,
1302
if stop_revision is None:
1303
stop_revision = self.source.last_revision()
1306
for k, v in viewitems(self.source.tags.get_tag_dict()):
1307
ret.append((None, v))
1308
ret.append((None, stop_revision))
1310
self.interrepo.fetch_objects(ret, lossy=lossy, limit=limit)
1311
except NoPushSupport:
1312
raise errors.NoRoundtrippingSupport(self.source, self.target)
1314
def pull(self, overwrite=False, stop_revision=None, local=False,
1315
possible_transports=None, run_hooks=True, _stop_revno=None):
1316
result = GitBranchPullResult()
1317
result.source_branch = self.source
1318
result.target_branch = self.target
1319
with self.source.lock_read(), self.target.lock_write():
1320
new_refs, main_ref, stop_revinfo = self._get_new_refs(
1321
stop_revision, stop_revno=_stop_revno)
1323
def update_refs(old_refs):
1324
return self._update_refs(result, old_refs, new_refs, overwrite)
1326
result.revidmap, old_refs, new_refs = (
1327
self.interrepo.fetch_refs(update_refs, lossy=False))
1328
except NoPushSupport:
1329
raise errors.NoRoundtrippingSupport(self.source, self.target)
1330
(old_sha1, result.old_revid) = old_refs.get(
1331
main_ref, (ZERO_SHA, NULL_REVISION))
1332
if result.old_revid is None:
1333
result.old_revid = self.target.lookup_foreign_revision_id(
1335
result.new_revid = new_refs[main_ref][1]
1336
result.local_branch = None
1337
result.master_branch = self.target
1339
for hook in branch.Branch.hooks['post_pull']:
1343
def push(self, overwrite=False, stop_revision=None, lossy=False,
1344
_override_hook_source_branch=None, _stop_revno=None):
1345
result = GitBranchPushResult()
1346
result.source_branch = self.source
1347
result.target_branch = self.target
1348
result.local_branch = None
1349
result.master_branch = result.target_branch
1350
with self.source.lock_read(), self.target.lock_write():
1351
new_refs, main_ref, stop_revinfo = self._get_new_refs(
1352
stop_revision, stop_revno=_stop_revno)
1354
def update_refs(old_refs):
1355
return self._update_refs(result, old_refs, new_refs, overwrite)
1357
result.revidmap, old_refs, new_refs = (
1358
self.interrepo.fetch_refs(
1359
update_refs, lossy=lossy, overwrite=overwrite))
1360
except NoPushSupport:
1361
raise errors.NoRoundtrippingSupport(self.source, self.target)
1362
(old_sha1, result.old_revid) = old_refs.get(
1363
main_ref, (ZERO_SHA, NULL_REVISION))
1364
if result.old_revid is None:
1365
result.old_revid = self.target.lookup_foreign_revision_id(
1367
result.new_revid = new_refs[main_ref][1]
1368
(result.new_original_revno,
1369
result.new_original_revid) = stop_revinfo
1370
for hook in branch.Branch.hooks['post_push']:
1375
branch.InterBranch.register_optimiser(InterGitLocalGitBranch)
1376
branch.InterBranch.register_optimiser(InterFromGitBranch)
1377
branch.InterBranch.register_optimiser(InterToGitBranch)
1378
branch.InterBranch.register_optimiser(InterLocalGitRemoteGitBranch)
added
removed
breezy/git/branch.py
