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 (
74
remote_refs_dict_to_tag_refs,
77
from .unpeel_map import (
80
from .urls import git_url_to_bzr_url
84
class GitPullResult(branch.PullResult):
85
"""Result of a pull from a Git branch."""
87
def _lookup_revno(self, revid):
88
if not isinstance(revid, bytes):
89
raise TypeError(revid)
90
# Try in source branch first, it'll be faster
91
with self.target_branch.lock_read():
92
return self.target_branch.revision_id_to_revno(revid)
96
return self._lookup_revno(self.old_revid)
100
return self._lookup_revno(self.new_revid)
103
class GitTags(tag.BasicTags):
104
"""Ref-based tag dictionary."""
106
def __init__(self, branch):
108
self.repository = branch.repository
110
def _merge_to_remote_git(self, target_repo, source_tag_refs, overwrite=False):
113
def get_changed_refs(old_refs):
115
for ref_name, tag_name, peeled, unpeeled in source_tag_refs.iteritems():
116
if old_refs.get(ref_name) == unpeeled:
118
elif overwrite or not ref_name in old_refs:
119
ret[ref_name] = unpeeled
120
updates[tag_name] = target_repo.lookup_foreign_revision_id(peeled)
124
self.repository.lookup_foreign_revision_id(peeled),
125
target_repo.lookup_foreign_revision_id(old_refs[ref_name])))
127
target_repo.controldir.send_pack(get_changed_refs, lambda have, want: [])
128
return updates, conflicts
130
def _merge_to_local_git(self, target_repo, source_tag_refs, overwrite=False):
133
for ref_name, tag_name, peeled, unpeeled in source_tag_refs:
134
if target_repo._git.refs.get(ref_name) == unpeeled:
136
elif overwrite or not ref_name in target_repo._git.refs:
137
target_repo._git.refs[ref_name] = unpeeled or peeled
138
updates[tag_name] = self.repository.lookup_foreign_revision_id(peeled)
140
source_revid = self.repository.lookup_foreign_revision_id(peeled)
142
target_revid = target_repo.lookup_foreign_revision_id(
143
target_repo._git.refs[ref_name])
145
trace.warning('%s does not point to a valid object',
148
conflicts.append((tag_name, source_revid, target_revid))
149
return updates, conflicts
151
def _merge_to_git(self, to_tags, source_tag_refs, overwrite=False):
152
target_repo = to_tags.repository
153
if self.repository.has_same_location(target_repo):
156
if getattr(target_repo, "_git", None):
157
return self._merge_to_local_git(target_repo, source_tag_refs, overwrite)
159
return self._merge_to_remote_git(target_repo, source_tag_refs, overwrite)
161
to_tags.branch._tag_refs = None
163
def _merge_to_non_git(self, to_tags, source_tag_refs, overwrite=False):
164
unpeeled_map = defaultdict(set)
167
result = dict(to_tags.get_tag_dict())
168
for ref_name, tag_name, peeled, unpeeled in source_tag_refs:
169
if unpeeled is not None:
170
unpeeled_map[peeled].add(unpeeled)
172
bzr_revid = self.branch.lookup_foreign_revision_id(peeled)
173
except NotCommitError:
175
if result.get(tag_name) == bzr_revid:
177
elif tag_name not in result or overwrite:
178
result[tag_name] = bzr_revid
179
updates[tag_name] = bzr_revid
181
conflicts.append((tag_name, bzr_revid, result[n]))
182
to_tags._set_tag_dict(result)
183
if len(unpeeled_map) > 0:
184
map_file = UnpeelMap.from_repository(to_tags.branch.repository)
185
map_file.update(unpeeled_map)
186
map_file.save_in_repository(to_tags.branch.repository)
187
return updates, conflicts
189
def merge_to(self, to_tags, overwrite=False, ignore_master=False,
190
source_tag_refs=None):
191
"""See Tags.merge_to."""
192
if source_tag_refs is None:
193
source_tag_refs = self.branch.get_tag_refs()
196
if isinstance(to_tags, GitTags):
197
return self._merge_to_git(to_tags, source_tag_refs,
203
master = to_tags.branch.get_master_branch()
204
if master is not None:
207
updates, conflicts = self._merge_to_non_git(to_tags, source_tag_refs,
209
if master is not None:
210
extra_updates, extra_conflicts = self.merge_to(
211
master.tags, overwrite=overwrite,
212
source_tag_refs=source_tag_refs,
213
ignore_master=ignore_master)
214
updates.update(extra_updates)
215
conflicts += extra_conflicts
216
return updates, conflicts
218
if master is not None:
221
def get_tag_dict(self):
223
for (ref_name, tag_name, peeled, unpeeled) in self.branch.get_tag_refs():
225
bzr_revid = self.branch.lookup_foreign_revision_id(peeled)
226
except NotCommitError:
229
ret[tag_name] = bzr_revid
233
class LocalGitTagDict(GitTags):
234
"""Dictionary with tags in a local repository."""
236
def __init__(self, branch):
237
super(LocalGitTagDict, self).__init__(branch)
238
self.refs = self.repository.controldir._git.refs
240
def _set_tag_dict(self, to_dict):
241
extra = set(self.refs.allkeys())
242
for k, revid in viewitems(to_dict):
243
name = tag_name_to_ref(k)
246
self.set_tag(k, revid)
249
del self.repository._git[name]
251
def set_tag(self, name, revid):
253
git_sha, mapping = self.branch.lookup_bzr_revision_id(revid)
254
except errors.NoSuchRevision:
255
raise errors.GhostTagsNotSupported(self)
256
self.refs[tag_name_to_ref(name)] = git_sha
257
self.branch._tag_refs = None
259
def delete_tag(self, name):
260
ref = tag_name_to_ref(name)
261
if not ref in self.refs:
262
raise errors.NoSuchTag(name)
264
self.branch._tag_refs = None
267
class GitBranchFormat(branch.BranchFormat):
269
def network_name(self):
272
def supports_tags(self):
275
def supports_leaving_lock(self):
278
def supports_tags_referencing_ghosts(self):
281
def tags_are_versioned(self):
284
def get_foreign_tests_branch_factory(self):
285
from .tests.test_branch import ForeignTestsBranchFactory
286
return ForeignTestsBranchFactory()
288
def make_tags(self, branch):
291
except AttributeError:
293
if getattr(branch.repository, "_git", None) is None:
294
from .remote import RemoteGitTagDict
295
return RemoteGitTagDict(branch)
297
return LocalGitTagDict(branch)
299
def initialize(self, a_controldir, name=None, repository=None,
300
append_revisions_only=None):
301
raise NotImplementedError(self.initialize)
303
def get_reference(self, controldir, name=None):
304
return controldir.get_branch_reference(name)
306
def set_reference(self, controldir, name, target):
307
return controldir.set_branch_reference(target, name)
310
class LocalGitBranchFormat(GitBranchFormat):
312
def get_format_description(self):
313
return 'Local Git Branch'
316
def _matchingcontroldir(self):
317
from .dir import LocalGitControlDirFormat
318
return LocalGitControlDirFormat()
320
def initialize(self, a_controldir, name=None, repository=None,
321
append_revisions_only=None):
322
from .dir import LocalGitDir
323
if not isinstance(a_controldir, LocalGitDir):
324
raise errors.IncompatibleFormat(self, a_controldir._format)
325
return a_controldir.create_branch(repository=repository, name=name,
326
append_revisions_only=append_revisions_only)
329
class GitBranch(ForeignBranch):
330
"""An adapter to git repositories for bzr Branch objects."""
333
def control_transport(self):
334
return self._control_transport
337
def user_transport(self):
338
return self._user_transport
340
def __init__(self, controldir, repository, ref, format):
341
self.repository = repository
342
self._format = format
343
self.controldir = controldir
344
self._lock_mode = None
346
super(GitBranch, self).__init__(repository.get_mapping())
349
self._user_transport = controldir.user_transport.clone('.')
350
self._control_transport = controldir.control_transport.clone('.')
351
self._tag_refs = None
354
self.name = ref_to_branch_name(ref)
357
if self.ref is not None:
358
params = {"ref": urlutils.escape(self.ref)}
361
params = {"branch": urlutils.escape(self.name)}
362
for k, v in params.items():
363
self._user_transport.set_segment_parameter(k, v)
364
self._control_transport.set_segment_parameter(k, v)
365
self.base = controldir.user_transport.base
367
def _get_checkout_format(self, lightweight=False):
368
"""Return the most suitable metadir for a checkout of this branch.
369
Weaves are used if this branch's repository uses weaves.
372
return controldir.format_registry.make_controldir("git")
374
return controldir.format_registry.make_controldir("default")
376
def get_child_submit_format(self):
377
"""Return the preferred format of submissions to this branch."""
378
ret = self.get_config_stack().get("child_submit_format")
383
def get_config(self):
384
return GitBranchConfig(self)
386
def get_config_stack(self):
387
return GitBranchStack(self)
389
def _get_nick(self, local=False, possible_master_transports=None):
390
"""Find the nick name for this branch.
394
cs = self.repository._git.get_config_stack()
396
return cs.get((b"branch", self.name.encode('utf-8')), b"nick").decode("utf-8")
399
return self.name or u"HEAD"
401
def _set_nick(self, nick):
402
cf = self.repository._git.get_config()
403
cf.set((b"branch", self.name.encode('utf-8')), b"nick", nick.encode("utf-8"))
406
self.repository._git._put_named_file('config', f.getvalue())
408
nick = property(_get_nick, _set_nick)
411
return "<%s(%r, %r)>" % (self.__class__.__name__, self.repository.base,
414
def generate_revision_history(self, revid, last_rev=None, other_branch=None):
415
if last_rev is not None:
416
graph = self.repository.get_graph()
417
if not graph.is_ancestor(last_rev, revid):
418
# our previous tip is not merged into stop_revision
419
raise errors.DivergedBranches(self, other_branch)
421
self.set_last_revision(revid)
423
def lock_write(self, token=None):
424
if token is not None:
425
raise errors.TokenLockingNotSupported(self)
427
if self._lock_mode == 'r':
428
raise errors.ReadOnlyError(self)
429
self._lock_count += 1
432
self._lock_mode = 'w'
434
self.repository.lock_write()
435
return lock.LogicalLockResult(self.unlock)
437
def leave_lock_in_place(self):
438
raise NotImplementedError(self.leave_lock_in_place)
440
def dont_leave_lock_in_place(self):
441
raise NotImplementedError(self.dont_leave_lock_in_place)
443
def get_stacked_on_url(self):
444
# Git doesn't do stacking (yet...)
445
raise branch.UnstackableBranchFormat(self._format, self.base)
447
def _get_parent_location(self):
448
"""See Branch.get_parent()."""
449
# FIXME: Set "origin" url from .git/config ?
450
cs = self.repository._git.get_config_stack()
452
location = cs.get((b"remote", b'origin'), b"url")
458
ref = cs.get((b"remote", b"origin"), b"merge")
464
params['branch'] = urlutils.escape(ref_to_branch_name(ref))
466
params['ref'] = urlutils.quote_from_bytes(ref)
468
url = git_url_to_bzr_url(location.decode('utf-8'))
469
return urlutils.join_segment_parameters(url, params)
471
def set_parent(self, location):
472
# FIXME: Set "origin" url in .git/config ?
473
cs = self.repository._git.get_config()
474
this_url = urlutils.split_segment_parameters(self.user_url)[0]
475
target_url, target_params = urlutils.split_segment_parameters(location)
476
location = urlutils.relative_url(this_url, target_url)
477
cs.set((b"remote", b"origin"), b"url", location)
478
if 'branch' in target_params:
479
cs.set((b"remote", b"origin"), b"merge",
480
branch_name_to_ref(target_params['branch']))
481
elif 'ref' in target_params:
482
cs.set((b"remote", b"origin"), b"merge",
483
target_params['ref'])
485
# TODO(jelmer): Maybe unset rather than setting to HEAD?
486
cs.set((b"remote", b"origin"), b"merge", 'HEAD')
489
self.repository._git._put_named_file('config', f.getvalue())
491
def break_lock(self):
492
raise NotImplementedError(self.break_lock)
496
if self._lock_mode not in ('r', 'w'):
497
raise ValueError(self._lock_mode)
498
self._lock_count += 1
500
self._lock_mode = 'r'
502
self.repository.lock_read()
503
return lock.LogicalLockResult(self.unlock)
505
def peek_lock_mode(self):
506
return self._lock_mode
509
return (self._lock_mode is not None)
514
def _unlock_ref(self):
518
"""See Branch.unlock()."""
519
if self._lock_count == 0:
520
raise errors.LockNotHeld(self)
522
self._lock_count -= 1
523
if self._lock_count == 0:
524
if self._lock_mode == 'w':
526
self._lock_mode = None
527
self._clear_cached_state()
529
self.repository.unlock()
531
def get_physical_lock_status(self):
534
def last_revision(self):
535
with self.lock_read():
536
# perhaps should escape this ?
537
if self.head is None:
538
return revision.NULL_REVISION
539
return self.lookup_foreign_revision_id(self.head)
541
def _basic_push(self, target, overwrite=False, stop_revision=None):
542
return branch.InterBranch.get(self, target)._basic_push(
543
overwrite, stop_revision)
545
def lookup_foreign_revision_id(self, foreign_revid):
547
return self.repository.lookup_foreign_revision_id(foreign_revid,
551
return self.mapping.revision_id_foreign_to_bzr(foreign_revid)
553
def lookup_bzr_revision_id(self, revid):
554
return self.repository.lookup_bzr_revision_id(
555
revid, mapping=self.mapping)
557
def get_unshelver(self, tree):
558
raise errors.StoringUncommittedNotSupported(self)
560
def _clear_cached_state(self):
561
super(GitBranch, self)._clear_cached_state()
562
self._tag_refs = None
564
def _iter_tag_refs(self, refs):
565
"""Iterate over the tag refs.
567
:param refs: Refs dictionary (name -> git sha1)
568
:return: iterator over (ref_name, tag_name, peeled_sha1, unpeeled_sha1)
570
raise NotImplementedError(self._iter_tag_refs)
572
def get_tag_refs(self):
573
with self.lock_read():
574
if self._tag_refs is None:
575
self._tag_refs = list(self._iter_tag_refs())
576
return self._tag_refs
579
class LocalGitBranch(GitBranch):
580
"""A local Git branch."""
582
def __init__(self, controldir, repository, ref):
583
super(LocalGitBranch, self).__init__(controldir, repository, ref,
584
LocalGitBranchFormat())
586
def create_checkout(self, to_location, revision_id=None, lightweight=False,
587
accelerator_tree=None, hardlink=False):
588
t = transport.get_transport(to_location)
590
format = self._get_checkout_format(lightweight=lightweight)
591
checkout = format.initialize_on_transport(t)
593
from_branch = checkout.set_branch_reference(target_branch=self)
595
policy = checkout.determine_repository_policy()
596
repo = policy.acquire_repository()[0]
598
checkout_branch = checkout.create_branch()
599
checkout_branch.bind(self)
600
checkout_branch.pull(self, stop_revision=revision_id)
602
return checkout.create_workingtree(revision_id,
603
from_branch=from_branch, hardlink=hardlink)
606
self._ref_lock = self.repository._git.refs.lock_ref(self.ref)
608
def _unlock_ref(self):
609
self._ref_lock.unlock()
611
def break_lock(self):
612
self.repository._git.refs.unlock_ref(self.ref)
614
def fetch(self, from_branch, last_revision=None, limit=None):
615
return branch.InterBranch.get(from_branch, self).fetch(
616
stop_revision=last_revision, limit=limit)
618
def _gen_revision_history(self):
619
if self.head is None:
621
last_revid = self.last_revision()
622
graph = self.repository.get_graph()
624
ret = list(graph.iter_lefthand_ancestry(last_revid,
625
(revision.NULL_REVISION, )))
626
except errors.RevisionNotPresent as e:
627
raise errors.GhostRevisionsHaveNoRevno(last_revid, e.revision_id)
633
return self.repository._git.refs[self.ref]
637
def _read_last_revision_info(self):
638
last_revid = self.last_revision()
639
graph = self.repository.get_graph()
641
revno = graph.find_distance_to_null(last_revid,
642
[(revision.NULL_REVISION, 0)])
643
except errors.GhostRevisionsHaveNoRevno:
645
return revno, last_revid
647
def set_last_revision_info(self, revno, revision_id):
648
self.set_last_revision(revision_id)
649
self._last_revision_info_cache = revno, revision_id
651
def set_last_revision(self, revid):
652
if not revid or not isinstance(revid, bytes):
653
raise errors.InvalidRevisionId(revision_id=revid, branch=self)
654
if revid == NULL_REVISION:
657
(newhead, self.mapping) = self.repository.lookup_bzr_revision_id(revid)
658
if self.mapping is None:
660
self._set_head(newhead)
662
def _set_head(self, value):
663
if value == ZERO_SHA:
664
raise ValueError(value)
667
del self.repository._git.refs[self.ref]
669
self.repository._git.refs[self.ref] = self._head
670
self._clear_cached_state()
672
head = property(_get_head, _set_head)
674
def get_push_location(self):
675
"""See Branch.get_push_location."""
676
push_loc = self.get_config_stack().get('push_location')
679
def set_push_location(self, location):
680
"""See Branch.set_push_location."""
681
self.get_config().set_user_option('push_location', location,
682
store=config.STORE_LOCATION)
684
def supports_tags(self):
687
def store_uncommitted(self, creator):
688
raise errors.StoringUncommittedNotSupported(self)
690
def _iter_tag_refs(self):
691
"""Iterate over the tag refs.
693
:param refs: Refs dictionary (name -> git sha1)
694
:return: iterator over (ref_name, tag_name, peeled_sha1, unpeeled_sha1)
696
refs = self.repository._git.refs
697
for ref_name, unpeeled in viewitems(refs.as_dict()):
699
tag_name = ref_to_tag_name(ref_name)
700
except (ValueError, UnicodeDecodeError):
702
peeled = refs.get_peeled(ref_name)
705
if not isinstance(tag_name, text_type):
706
raise TypeError(tag_name)
707
yield (ref_name, tag_name, peeled, unpeeled)
709
def create_memorytree(self):
710
from .memorytree import GitMemoryTree
711
return GitMemoryTree(self, self.repository._git.object_store, self.head)
713
def reference_parent(self, path, file_id=None, possible_transports=None):
714
"""Return the parent branch for a tree-reference file_id
716
:param path: The path of the file_id in the tree
717
:param file_id: Optional file_id of the tree reference
718
:return: A branch associated with the file_id
720
# FIXME should provide multiple branches, based on config
721
url = urlutils.join(self.user_url, path)
722
return branch.Branch.open(
724
possible_transports=possible_transports)
728
def _quick_lookup_revno(local_branch, remote_branch, revid):
729
if not isinstance(revid, bytes):
730
raise TypeError(revid)
731
# Try in source branch first, it'll be faster
732
with local_branch.lock_read():
734
return local_branch.revision_id_to_revno(revid)
735
except errors.NoSuchRevision:
736
graph = local_branch.repository.get_graph()
738
return graph.find_distance_to_null(revid,
739
[(revision.NULL_REVISION, 0)])
740
except errors.GhostRevisionsHaveNoRevno:
741
# FIXME: Check using graph.find_distance_to_null() ?
742
with remote_branch.lock_read():
743
return remote_branch.revision_id_to_revno(revid)
746
class GitBranchPullResult(branch.PullResult):
749
super(GitBranchPullResult, self).__init__()
750
self.new_git_head = None
751
self._old_revno = None
752
self._new_revno = None
754
def report(self, to_file):
756
if self.old_revid == self.new_revid:
757
to_file.write('No revisions to pull.\n')
758
elif self.new_git_head is not None:
759
to_file.write('Now on revision %d (git sha: %s).\n' %
760
(self.new_revno, self.new_git_head))
762
to_file.write('Now on revision %d.\n' % (self.new_revno,))
763
self._show_tag_conficts(to_file)
765
def _lookup_revno(self, revid):
766
return _quick_lookup_revno(self.target_branch, self.source_branch,
769
def _get_old_revno(self):
770
if self._old_revno is not None:
771
return self._old_revno
772
return self._lookup_revno(self.old_revid)
774
def _set_old_revno(self, revno):
775
self._old_revno = revno
777
old_revno = property(_get_old_revno, _set_old_revno)
779
def _get_new_revno(self):
780
if self._new_revno is not None:
781
return self._new_revno
782
return self._lookup_revno(self.new_revid)
784
def _set_new_revno(self, revno):
785
self._new_revno = revno
787
new_revno = property(_get_new_revno, _set_new_revno)
790
class GitBranchPushResult(branch.BranchPushResult):
792
def _lookup_revno(self, revid):
793
return _quick_lookup_revno(self.source_branch, self.target_branch,
798
return self._lookup_revno(self.old_revid)
802
new_original_revno = getattr(self, "new_original_revno", None)
803
if new_original_revno:
804
return new_original_revno
805
if getattr(self, "new_original_revid", None) is not None:
806
return self._lookup_revno(self.new_original_revid)
807
return self._lookup_revno(self.new_revid)
810
class InterFromGitBranch(branch.GenericInterBranch):
811
"""InterBranch implementation that pulls from Git into bzr."""
814
def _get_branch_formats_to_test():
816
default_format = branch.format_registry.get_default()
817
except AttributeError:
818
default_format = branch.BranchFormat._default_format
819
from .remote import RemoteGitBranchFormat
821
(RemoteGitBranchFormat(), default_format),
822
(LocalGitBranchFormat(), default_format)]
825
def _get_interrepo(self, source, target):
826
return _mod_repository.InterRepository.get(source.repository, target.repository)
829
def is_compatible(cls, source, target):
830
if not isinstance(source, GitBranch):
832
if isinstance(target, GitBranch):
833
# InterLocalGitRemoteGitBranch or InterToGitBranch should be used
835
if getattr(cls._get_interrepo(source, target), "fetch_objects", None) is None:
836
# fetch_objects is necessary for this to work
840
def fetch(self, stop_revision=None, fetch_tags=None, limit=None):
841
self.fetch_objects(stop_revision, fetch_tags=fetch_tags, limit=limit)
843
def fetch_objects(self, stop_revision, fetch_tags, limit=None):
844
interrepo = self._get_interrepo(self.source, self.target)
845
if fetch_tags is None:
846
c = self.source.get_config_stack()
847
fetch_tags = c.get('branch.fetch_tags')
848
def determine_wants(heads):
849
if stop_revision is None:
851
head = heads[self.source.ref]
853
self._last_revid = revision.NULL_REVISION
855
self._last_revid = self.source.lookup_foreign_revision_id(head)
857
self._last_revid = stop_revision
858
real = interrepo.get_determine_wants_revids(
859
[self._last_revid], include_tags=fetch_tags)
861
pack_hint, head, refs = interrepo.fetch_objects(
862
determine_wants, self.source.mapping, limit=limit)
863
if (pack_hint is not None and
864
self.target.repository._format.pack_compresses):
865
self.target.repository.pack(hint=pack_hint)
868
def _update_revisions(self, stop_revision=None, overwrite=False):
869
head, refs = self.fetch_objects(stop_revision, fetch_tags=None)
871
prev_last_revid = None
873
prev_last_revid = self.target.last_revision()
874
self.target.generate_revision_history(self._last_revid,
875
last_rev=prev_last_revid, other_branch=self.source)
878
def _basic_pull(self, stop_revision, overwrite, run_hooks,
879
_override_hook_target, _hook_master):
880
if overwrite is True:
881
overwrite = set(["history", "tags"])
884
result = GitBranchPullResult()
885
result.source_branch = self.source
886
if _override_hook_target is None:
887
result.target_branch = self.target
889
result.target_branch = _override_hook_target
890
with self.target.lock_write(), self.source.lock_read():
891
# We assume that during 'pull' the target repository is closer than
893
(result.old_revno, result.old_revid) = \
894
self.target.last_revision_info()
895
result.new_git_head, remote_refs = self._update_revisions(
896
stop_revision, overwrite=("history" in overwrite))
897
tags_ret = self.source.tags.merge_to(
898
self.target.tags, ("tags" in overwrite), ignore_master=True)
899
if isinstance(tags_ret, tuple):
900
result.tag_updates, result.tag_conflicts = tags_ret
902
result.tag_conflicts = tags_ret
903
(result.new_revno, result.new_revid) = \
904
self.target.last_revision_info()
906
result.master_branch = _hook_master
907
result.local_branch = result.target_branch
909
result.master_branch = result.target_branch
910
result.local_branch = None
912
for hook in branch.Branch.hooks['post_pull']:
916
def pull(self, overwrite=False, stop_revision=None,
917
possible_transports=None, _hook_master=None, run_hooks=True,
918
_override_hook_target=None, local=False):
921
:param _hook_master: Private parameter - set the branch to
922
be supplied as the master to pull hooks.
923
:param run_hooks: Private parameter - if false, this branch
924
is being called because it's the master of the primary branch,
925
so it should not run its hooks.
926
:param _override_hook_target: Private parameter - set the branch to be
927
supplied as the target_branch to pull hooks.
929
# This type of branch can't be bound.
930
bound_location = self.target.get_bound_location()
931
if local and not bound_location:
932
raise errors.LocalRequiresBoundBranch()
934
source_is_master = False
935
self.source.lock_read()
937
# bound_location comes from a config file, some care has to be
938
# taken to relate it to source.user_url
939
normalized = urlutils.normalize_url(bound_location)
941
relpath = self.source.user_transport.relpath(normalized)
942
source_is_master = (relpath == '')
943
except (errors.PathNotChild, urlutils.InvalidURL):
944
source_is_master = False
945
if not local and bound_location and not source_is_master:
946
# not pulling from master, so we need to update master.
947
master_branch = self.target.get_master_branch(possible_transports)
948
master_branch.lock_write()
952
# pull from source into master.
953
master_branch.pull(self.source, overwrite, stop_revision,
955
result = self._basic_pull(stop_revision, overwrite, run_hooks,
956
_override_hook_target, _hook_master=master_branch)
961
master_branch.unlock()
964
def _basic_push(self, overwrite, stop_revision):
965
if overwrite is True:
966
overwrite = set(["history", "tags"])
969
result = branch.BranchPushResult()
970
result.source_branch = self.source
971
result.target_branch = self.target
972
result.old_revno, result.old_revid = self.target.last_revision_info()
973
result.new_git_head, remote_refs = self._update_revisions(
974
stop_revision, overwrite=("history" in overwrite))
975
tags_ret = self.source.tags.merge_to(self.target.tags,
976
"tags" in overwrite, ignore_master=True)
977
(result.tag_updates, result.tag_conflicts) = tags_ret
978
result.new_revno, result.new_revid = self.target.last_revision_info()
982
class InterGitBranch(branch.GenericInterBranch):
983
"""InterBranch implementation that pulls between Git branches."""
985
def fetch(self, stop_revision=None, fetch_tags=None, limit=None):
986
raise NotImplementedError(self.fetch)
989
class InterLocalGitRemoteGitBranch(InterGitBranch):
990
"""InterBranch that copies from a local to a remote git branch."""
993
def _get_branch_formats_to_test():
994
from .remote import RemoteGitBranchFormat
996
(LocalGitBranchFormat(), RemoteGitBranchFormat())]
999
def is_compatible(self, source, target):
1000
from .remote import RemoteGitBranch
1001
return (isinstance(source, LocalGitBranch) and
1002
isinstance(target, RemoteGitBranch))
1004
def _basic_push(self, overwrite, stop_revision):
1005
result = GitBranchPushResult()
1006
result.source_branch = self.source
1007
result.target_branch = self.target
1008
if stop_revision is None:
1009
stop_revision = self.source.last_revision()
1010
def get_changed_refs(old_refs):
1011
old_ref = old_refs.get(self.target.ref, None)
1013
result.old_revid = revision.NULL_REVISION
1015
result.old_revid = self.target.lookup_foreign_revision_id(old_ref)
1016
new_ref = self.source.repository.lookup_bzr_revision_id(stop_revision)[0]
1018
if remote_divergence(old_ref, new_ref, self.source.repository._git.object_store):
1019
raise errors.DivergedBranches(self.source, self.target)
1020
refs = { self.target.ref: new_ref }
1021
result.new_revid = stop_revision
1022
for name, sha in viewitems(self.source.repository._git.refs.as_dict(b"refs/tags")):
1023
refs[tag_name_to_ref(name)] = sha
1025
self.target.repository.send_pack(get_changed_refs,
1026
self.source.repository._git.object_store.generate_pack_data)
1030
class InterGitLocalGitBranch(InterGitBranch):
1031
"""InterBranch that copies from a remote to a local git branch."""
1034
def _get_branch_formats_to_test():
1035
from .remote import RemoteGitBranchFormat
1037
(RemoteGitBranchFormat(), LocalGitBranchFormat()),
1038
(LocalGitBranchFormat(), LocalGitBranchFormat())]
1041
def is_compatible(self, source, target):
1042
return (isinstance(source, GitBranch) and
1043
isinstance(target, LocalGitBranch))
1045
def fetch(self, stop_revision=None, fetch_tags=None, limit=None):
1046
interrepo = _mod_repository.InterRepository.get(self.source.repository,
1047
self.target.repository)
1048
if stop_revision is None:
1049
stop_revision = self.source.last_revision()
1050
determine_wants = interrepo.get_determine_wants_revids(
1051
[stop_revision], include_tags=fetch_tags)
1052
interrepo.fetch_objects(determine_wants, limit=limit)
1054
def _basic_push(self, overwrite=False, stop_revision=None):
1055
if overwrite is True:
1056
overwrite = set(["history", "tags"])
1059
result = GitBranchPushResult()
1060
result.source_branch = self.source
1061
result.target_branch = self.target
1062
result.old_revid = self.target.last_revision()
1063
refs, stop_revision = self.update_refs(stop_revision)
1064
self.target.generate_revision_history(stop_revision,
1065
(result.old_revid if ("history" not in overwrite) else None),
1066
other_branch=self.source)
1067
tags_ret = self.source.tags.merge_to(self.target.tags,
1068
source_tag_refs=remote_refs_dict_to_tag_refs(refs),
1069
overwrite=("tags" in overwrite))
1070
if isinstance(tags_ret, tuple):
1071
(result.tag_updates, result.tag_conflicts) = tags_ret
1073
result.tag_conflicts = tags_ret
1074
result.new_revid = self.target.last_revision()
1077
def update_refs(self, stop_revision=None):
1078
interrepo = _mod_repository.InterRepository.get(
1079
self.source.repository, self.target.repository)
1080
c = self.source.get_config_stack()
1081
fetch_tags = c.get('branch.fetch_tags')
1083
if stop_revision is None:
1084
refs = interrepo.fetch(branches=[b"HEAD"], include_tags=fetch_tags)
1086
head = refs[b"HEAD"]
1088
stop_revision = revision.NULL_REVISION
1090
stop_revision = self.target.lookup_foreign_revision_id(head)
1092
refs = interrepo.fetch(revision_id=stop_revision, include_tags=fetch_tags)
1093
return refs, stop_revision
1095
def pull(self, stop_revision=None, overwrite=False,
1096
possible_transports=None, run_hooks=True, local=False):
1097
# This type of branch can't be bound.
1099
raise errors.LocalRequiresBoundBranch()
1100
if overwrite is True:
1101
overwrite = set(["history", "tags"])
1105
result = GitPullResult()
1106
result.source_branch = self.source
1107
result.target_branch = self.target
1108
with self.target.lock_write(), self.source.lock_read():
1109
result.old_revid = self.target.last_revision()
1110
refs, stop_revision = self.update_refs(stop_revision)
1111
self.target.generate_revision_history(stop_revision,
1112
(result.old_revid if ("history" not in overwrite) else None),
1113
other_branch=self.source)
1114
tags_ret = self.source.tags.merge_to(self.target.tags,
1115
overwrite=("tags" in overwrite),
1116
source_tag_refs=remote_refs_dict_to_tag_refs(refs))
1117
if isinstance(tags_ret, tuple):
1118
(result.tag_updates, result.tag_conflicts) = tags_ret
1120
result.tag_conflicts = tags_ret
1121
result.new_revid = self.target.last_revision()
1122
result.local_branch = None
1123
result.master_branch = result.target_branch
1125
for hook in branch.Branch.hooks['post_pull']:
1130
class InterToGitBranch(branch.GenericInterBranch):
1131
"""InterBranch implementation that pulls from a non-bzr into a Git branch."""
1133
def __init__(self, source, target):
1134
super(InterToGitBranch, self).__init__(source, target)
1135
self.interrepo = _mod_repository.InterRepository.get(source.repository,
1139
def _get_branch_formats_to_test():
1141
default_format = branch.format_registry.get_default()
1142
except AttributeError:
1143
default_format = branch.BranchFormat._default_format
1144
from .remote import RemoteGitBranchFormat
1146
(default_format, LocalGitBranchFormat()),
1147
(default_format, RemoteGitBranchFormat())]
1150
def is_compatible(self, source, target):
1151
return (not isinstance(source, GitBranch) and
1152
isinstance(target, GitBranch))
1154
def _get_new_refs(self, stop_revision=None, fetch_tags=None):
1155
if not self.source.is_locked():
1156
raise errors.ObjectNotLocked(self.source)
1157
if stop_revision is None:
1158
(stop_revno, stop_revision) = self.source.last_revision_info()
1160
stop_revno = self.source.revision_id_to_revno(stop_revision)
1161
if not isinstance(stop_revision, bytes):
1162
raise TypeError(stop_revision)
1163
main_ref = self.target.ref
1164
refs = { main_ref: (None, stop_revision) }
1165
if fetch_tags is None:
1166
c = self.source.get_config_stack()
1167
fetch_tags = c.get('branch.fetch_tags')
1168
for name, revid in viewitems(self.source.tags.get_tag_dict()):
1169
if self.source.repository.has_revision(revid):
1170
ref = tag_name_to_ref(name)
1171
if not check_ref_format(ref):
1172
warning("skipping tag with invalid characters %s (%s)",
1176
# FIXME: Skip tags that are not in the ancestry
1177
refs[ref] = (None, revid)
1178
return refs, main_ref, (stop_revno, stop_revision)
1180
def _update_refs(self, result, old_refs, new_refs, overwrite):
1181
mutter("updating refs. old refs: %r, new refs: %r",
1183
result.tag_updates = {}
1184
result.tag_conflicts = []
1185
ret = dict(old_refs)
1186
def ref_equals(refs, ref, git_sha, revid):
1191
if (value[0] is not None and
1192
git_sha is not None and
1193
value[0] == git_sha):
1195
if (value[1] is not None and
1196
revid is not None and
1199
# FIXME: If one side only has the git sha available and the other only
1200
# has the bzr revid, then this will cause us to show a tag as updated
1201
# that hasn't actually been updated.
1203
# FIXME: Check for diverged branches
1204
for ref, (git_sha, revid) in viewitems(new_refs):
1205
if ref_equals(ret, ref, git_sha, revid):
1206
# Already up to date
1208
git_sha = old_refs[ref][0]
1210
revid = old_refs[ref][1]
1211
ret[ref] = new_refs[ref] = (git_sha, revid)
1212
elif ref not in ret or overwrite:
1214
tag_name = ref_to_tag_name(ref)
1218
result.tag_updates[tag_name] = revid
1219
ret[ref] = (git_sha, revid)
1221
# FIXME: Check diverged
1225
name = ref_to_tag_name(ref)
1229
result.tag_conflicts.append((name, revid, ret[name][1]))
1231
ret[ref] = (git_sha, revid)
1234
def fetch(self, stop_revision=None, fetch_tags=None, lossy=False, limit=None):
1235
if stop_revision is None:
1236
stop_revision = self.source.last_revision()
1239
for k, v in viewitems(self.source.tags.get_tag_dict()):
1240
ret.append((None, v))
1241
ret.append((None, stop_revision))
1243
self.interrepo.fetch_objects(ret, lossy=lossy, limit=limit)
1244
except NoPushSupport:
1245
raise errors.NoRoundtrippingSupport(self.source, self.target)
1247
def pull(self, overwrite=False, stop_revision=None, local=False,
1248
possible_transports=None, run_hooks=True):
1249
result = GitBranchPullResult()
1250
result.source_branch = self.source
1251
result.target_branch = self.target
1252
with self.source.lock_read(), self.target.lock_write():
1253
new_refs, main_ref, stop_revinfo = self._get_new_refs(
1255
def update_refs(old_refs):
1256
return self._update_refs(result, old_refs, new_refs, overwrite)
1258
result.revidmap, old_refs, new_refs = self.interrepo.fetch_refs(
1259
update_refs, lossy=False)
1260
except NoPushSupport:
1261
raise errors.NoRoundtrippingSupport(self.source, self.target)
1262
(old_sha1, result.old_revid) = old_refs.get(main_ref, (ZERO_SHA, NULL_REVISION))
1263
if result.old_revid is None:
1264
result.old_revid = self.target.lookup_foreign_revision_id(old_sha1)
1265
result.new_revid = new_refs[main_ref][1]
1266
result.local_branch = None
1267
result.master_branch = self.target
1269
for hook in branch.Branch.hooks['post_pull']:
1273
def push(self, overwrite=False, stop_revision=None, lossy=False,
1274
_override_hook_source_branch=None):
1275
result = GitBranchPushResult()
1276
result.source_branch = self.source
1277
result.target_branch = self.target
1278
result.local_branch = None
1279
result.master_branch = result.target_branch
1280
with self.source.lock_read(), self.target.lock_write():
1281
new_refs, main_ref, stop_revinfo = self._get_new_refs(stop_revision)
1282
def update_refs(old_refs):
1283
return self._update_refs(result, old_refs, new_refs, overwrite)
1285
result.revidmap, old_refs, new_refs = self.interrepo.fetch_refs(
1286
update_refs, lossy=lossy, overwrite=overwrite)
1287
except NoPushSupport:
1288
raise errors.NoRoundtrippingSupport(self.source, self.target)
1289
(old_sha1, result.old_revid) = old_refs.get(main_ref, (ZERO_SHA, NULL_REVISION))
1290
if result.old_revid is None:
1291
result.old_revid = self.target.lookup_foreign_revision_id(old_sha1)
1292
result.new_revid = new_refs[main_ref][1]
1293
(result.new_original_revno, result.new_original_revid) = stop_revinfo
1294
for hook in branch.Branch.hooks['post_push']:
1299
branch.InterBranch.register_optimiser(InterGitLocalGitBranch)
1300
branch.InterBranch.register_optimiser(InterFromGitBranch)
1301
branch.InterBranch.register_optimiser(InterToGitBranch)
1302
branch.InterBranch.register_optimiser(InterLocalGitRemoteGitBranch)