1
# Copyright (C) 2007 Canonical Ltd
2
# Copyright (C) 2009-2010 Jelmer Vernooij <jelmer@samba.org>
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18
"""An adapter between a Git Branch and a Bazaar Branch"""
20
from dulwich.objects import (
35
from bzrlib.decorators import (
38
from bzrlib.trace import (
43
from bzrlib.plugins.git.config import (
46
from bzrlib.plugins.git.errors import (
50
from bzrlib.plugins.git.refs import (
56
from bzrlib.foreign import ForeignBranch
59
class GitPullResult(branch.PullResult):
60
"""Result of a pull from a Git branch."""
62
def _lookup_revno(self, revid):
63
assert isinstance(revid, str), "was %r" % revid
64
# Try in source branch first, it'll be faster
65
return self.target_branch.revision_id_to_revno(revid)
69
return self._lookup_revno(self.old_revid)
73
return self._lookup_revno(self.new_revid)
76
class LocalGitTagDict(tag.BasicTags):
77
"""Dictionary with tags in a local repository."""
79
def __init__(self, branch):
81
self.repository = branch.repository
83
def get_tag_dict(self):
85
for k,v in extract_tags(self.repository._git.get_refs()).iteritems():
87
obj = self.repository._git[v]
89
mutter("Tag %s points at unknown object %s, ignoring", v, obj)
91
while isinstance(obj, Tag):
93
obj = self.repository._git[v]
94
if not isinstance(obj, Commit):
95
mutter("Tag %s points at object %r that is not a commit, "
98
ret[k] = self.branch.lookup_foreign_revision_id(v)
101
def _set_tag_dict(self, to_dict):
102
extra = set(self.repository._git.get_refs().keys())
103
for k, revid in to_dict.iteritems():
104
name = tag_name_to_ref(k)
107
self.set_tag(k, revid)
109
if name.startswith("refs/tags/"):
110
del self.repository._git[name]
112
def set_tag(self, name, revid):
113
self.repository._git.refs[tag_name_to_ref(name)], _ = \
114
self.branch.mapping.revision_id_bzr_to_foreign(revid)
117
class DictTagDict(LocalGitTagDict):
119
def __init__(self, branch, tags):
120
super(DictTagDict, self).__init__(branch)
123
def get_tag_dict(self):
127
class GitBranchFormat(branch.BranchFormat):
129
def get_format_description(self):
132
def network_name(self):
135
def supports_tags(self):
138
def get_foreign_tests_branch_factory(self):
139
from bzrlib.plugins.git.tests.test_branch import ForeignTestsBranchFactory
140
return ForeignTestsBranchFactory()
142
def make_tags(self, branch):
143
if getattr(branch.repository, "get_refs", None) is not None:
144
from bzrlib.plugins.git.remote import RemoteGitTagDict
145
return RemoteGitTagDict(branch)
147
return LocalGitTagDict(branch)
150
class GitReadLock(object):
152
def __init__(self, unlock):
156
class GitWriteLock(object):
158
def __init__(self, unlock):
162
class GitBranch(ForeignBranch):
163
"""An adapter to git repositories for bzr Branch objects."""
165
def __init__(self, bzrdir, repository, ref, lockfiles, tagsdict=None):
166
self.repository = repository
167
self._format = GitBranchFormat()
168
self.control_files = lockfiles
170
super(GitBranch, self).__init__(repository.get_mapping())
171
if tagsdict is not None:
172
self.tags = DictTagDict(self, tagsdict)
174
self.name = ref_to_branch_name(ref)
176
self.base = bzrdir.root_transport.base
178
def _get_checkout_format(self):
179
"""Return the most suitable metadir for a checkout of this branch.
180
Weaves are used if this branch's repository uses weaves.
182
return bzrdir.format_registry.make_bzrdir("default")
184
def get_child_submit_format(self):
185
"""Return the preferred format of submissions to this branch."""
186
ret = self.get_config().get_user_option("child_submit_format")
191
def _get_nick(self, local=False, possible_master_transports=None):
192
"""Find the nick name for this branch.
196
return self.name or "HEAD"
198
def _set_nick(self, nick):
199
raise NotImplementedError
201
nick = property(_get_nick, _set_nick)
204
return "<%s(%r, %r)>" % (self.__class__.__name__, self.repository.base,
207
def generate_revision_history(self, revid, old_revid=None):
208
# FIXME: Check that old_revid is in the ancestry of revid
209
newhead, self.mapping = self.mapping.revision_id_bzr_to_foreign(revid)
210
self._set_head(newhead)
212
def lock_write(self):
213
self.control_files.lock_write()
214
return GitWriteLock(self.unlock)
216
def get_stacked_on_url(self):
217
# Git doesn't do stacking (yet...)
218
raise errors.UnstackableBranchFormat(self._format, self.base)
220
def get_parent(self):
221
"""See Branch.get_parent()."""
222
# FIXME: Set "origin" url from .git/config ?
225
def set_parent(self, url):
226
# FIXME: Set "origin" url in .git/config ?
230
self.control_files.lock_read()
231
return GitReadLock(self.unlock)
234
return self.control_files.is_locked()
237
self.control_files.unlock()
239
def get_physical_lock_status(self):
243
def last_revision(self):
244
# perhaps should escape this ?
245
if self.head is None:
246
return revision.NULL_REVISION
247
return self.lookup_foreign_revision_id(self.head)
249
def _basic_push(self, target, overwrite=False, stop_revision=None):
250
return branch.InterBranch.get(self, target)._basic_push(
251
overwrite, stop_revision)
253
def lookup_foreign_revision_id(self, foreign_revid):
254
return self.repository.lookup_foreign_revision_id(foreign_revid,
258
class LocalGitBranch(GitBranch):
259
"""A local Git branch."""
261
def __init__(self, bzrdir, repository, name, lockfiles, tagsdict=None):
262
super(LocalGitBranch, self).__init__(bzrdir, repository, name,
264
refs = repository._git.get_refs()
265
if not (name in refs.keys() or "HEAD" in refs.keys()):
266
raise errors.NotBranchError(self.base)
268
def create_checkout(self, to_location, revision_id=None, lightweight=False,
269
accelerator_tree=None, hardlink=False):
271
t = transport.get_transport(to_location)
273
format = self._get_checkout_format()
274
checkout = format.initialize_on_transport(t)
275
from_branch = branch.BranchReferenceFormat().initialize(checkout,
277
tree = checkout.create_workingtree(revision_id,
278
from_branch=from_branch, hardlink=hardlink)
281
return self._create_heavyweight_checkout(to_location, revision_id,
284
def _create_heavyweight_checkout(self, to_location, revision_id=None,
286
"""Create a new heavyweight checkout of this branch.
288
:param to_location: URL of location to create the new checkout in.
289
:param revision_id: Revision that should be the tip of the checkout.
290
:param hardlink: Whether to hardlink
291
:return: WorkingTree object of checkout.
293
checkout_branch = bzrdir.BzrDir.create_branch_convenience(
294
to_location, force_new_tree=False)
295
checkout = checkout_branch.bzrdir
296
checkout_branch.bind(self)
297
# pull up to the specified revision_id to set the initial
298
# branch tip correctly, and seed it with history.
299
checkout_branch.pull(self, stop_revision=revision_id)
300
return checkout.create_workingtree(revision_id, hardlink=hardlink)
302
def _gen_revision_history(self):
303
if self.head is None:
305
ret = list(self.repository.iter_reverse_revision_history(
306
self.last_revision()))
312
return self.repository._git.ref(self.ref or "HEAD")
316
def set_last_revision_info(self, revno, revid):
317
self.set_last_revision(revid)
319
def set_last_revision(self, revid):
320
(newhead, self.mapping) = self.repository.lookup_bzr_revision_id(revid)
323
def _set_head(self, value):
325
self.repository._git.refs[self.ref or "HEAD"] = self._head
326
self._clear_cached_state()
328
head = property(_get_head, _set_head)
330
def get_config(self):
331
return GitBranchConfig(self)
333
def get_push_location(self):
334
"""See Branch.get_push_location."""
335
push_loc = self.get_config().get_user_option('push_location')
338
def set_push_location(self, location):
339
"""See Branch.set_push_location."""
340
self.get_config().set_user_option('push_location', location,
341
store=config.STORE_LOCATION)
343
def supports_tags(self):
347
class GitBranchPullResult(branch.PullResult):
350
super(GitBranchPullResult, self).__init__()
351
self.new_git_head = None
352
self._old_revno = None
353
self._new_revno = None
355
def report(self, to_file):
357
if self.old_revid == self.new_revid:
358
to_file.write('No revisions to pull.\n')
359
elif self.new_git_head is not None:
360
to_file.write('Now on revision %d (git sha: %s).\n' %
361
(self.new_revno, self.new_git_head))
363
to_file.write('Now on revision %d.\n' % (self.new_revno,))
364
self._show_tag_conficts(to_file)
366
def _lookup_revno(self, revid):
367
assert isinstance(revid, str), "was %r" % revid
368
# Try in source branch first, it'll be faster
370
return self.source_branch.revision_id_to_revno(revid)
371
except errors.NoSuchRevision:
372
# FIXME: Check using graph.find_distance_to_null() ?
373
return self.target_branch.revision_id_to_revno(revid)
375
def _get_old_revno(self):
376
if self._old_revno is not None:
377
return self._old_revno
378
return self._lookup_revno(self.old_revid)
380
def _set_old_revno(self, revno):
381
self._old_revno = revno
383
old_revno = property(_get_old_revno, _set_old_revno)
385
def _get_new_revno(self):
386
if self._new_revno is not None:
387
return self._new_revno
388
return self._lookup_revno(self.new_revid)
390
def _set_new_revno(self, revno):
391
self._new_revno = revno
393
new_revno = property(_get_new_revno, _set_new_revno)
396
class GitBranchPushResult(branch.BranchPushResult):
398
def _lookup_revno(self, revid):
399
assert isinstance(revid, str), "was %r" % revid
400
# Try in source branch first, it'll be faster
402
return self.source_branch.revision_id_to_revno(revid)
403
except errors.NoSuchRevision:
404
# FIXME: Check using graph.find_distance_to_null() ?
405
return self.target_branch.revision_id_to_revno(revid)
409
return self._lookup_revno(self.old_revid)
413
return self._lookup_revno(self.new_revid)
416
class InterFromGitBranch(branch.GenericInterBranch):
417
"""InterBranch implementation that pulls from Git into bzr."""
420
def _get_interrepo(self, source, target):
421
return repository.InterRepository.get(source.repository,
425
def is_compatible(cls, source, target):
426
return (isinstance(source, GitBranch) and
427
not isinstance(target, GitBranch) and
428
(getattr(cls._get_interrepo(source, target), "fetch_objects", None) is not None))
430
def _update_revisions(self, stop_revision=None, overwrite=False,
431
graph=None, limit=None):
432
"""Like InterBranch.update_revisions(), but with additions.
434
Compared to the `update_revisions()` below, this function takes a
435
`limit` argument that limits how many git commits will be converted
436
and returns the new git head.
438
interrepo = self._get_interrepo(self.source, self.target)
439
def determine_wants(heads):
440
if self.source.ref is not None and not self.source.ref in heads:
441
raise NoSuchRef(self.source.ref, heads.keys())
442
if stop_revision is not None:
443
self._last_revid = stop_revision
444
head, mapping = self.source.repository.lookup_bzr_revision_id(
447
if self.source.ref is not None:
448
head = heads[self.source.ref]
451
self._last_revid = self.source.lookup_foreign_revision_id(head)
452
if self.target.repository.has_revision(self._last_revid):
455
pack_hint, head = interrepo.fetch_objects(
456
determine_wants, self.source.mapping, limit=limit)
457
if (pack_hint is not None and
458
self.target.repository._format.pack_compresses):
459
self.target.repository.pack(hint=pack_hint)
461
self._last_revid = self.source.lookup_foreign_revision_id(head)
463
prev_last_revid = None
465
prev_last_revid = self.target.last_revision()
466
self.target.generate_revision_history(self._last_revid,
470
def update_revisions(self, stop_revision=None, overwrite=False,
472
"""See InterBranch.update_revisions()."""
473
self._update_revisions(stop_revision, overwrite, graph)
475
def pull(self, overwrite=False, stop_revision=None,
476
possible_transports=None, _hook_master=None, run_hooks=True,
477
_override_hook_target=None, local=False, limit=None):
480
:param _hook_master: Private parameter - set the branch to
481
be supplied as the master to pull hooks.
482
:param run_hooks: Private parameter - if false, this branch
483
is being called because it's the master of the primary branch,
484
so it should not run its hooks.
485
:param _override_hook_target: Private parameter - set the branch to be
486
supplied as the target_branch to pull hooks.
487
:param limit: Only import this many revisons. `None`, the default,
488
means import all revisions.
490
# This type of branch can't be bound.
492
raise errors.LocalRequiresBoundBranch()
493
result = GitBranchPullResult()
494
result.source_branch = self.source
495
if _override_hook_target is None:
496
result.target_branch = self.target
498
result.target_branch = _override_hook_target
499
self.source.lock_read()
501
# We assume that during 'pull' the target repository is closer than
503
graph = self.target.repository.get_graph(self.source.repository)
504
(result.old_revno, result.old_revid) = \
505
self.target.last_revision_info()
506
result.new_git_head = self._update_revisions(
507
stop_revision, overwrite=overwrite, graph=graph, limit=limit)
508
result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
510
(result.new_revno, result.new_revid) = \
511
self.target.last_revision_info()
513
result.master_branch = _hook_master
514
result.local_branch = result.target_branch
516
result.master_branch = result.target_branch
517
result.local_branch = None
519
for hook in branch.Branch.hooks['post_pull']:
525
def _basic_push(self, overwrite=False, stop_revision=None):
526
result = branch.BranchPushResult()
527
result.source_branch = self.source
528
result.target_branch = self.target
529
graph = self.target.repository.get_graph(self.source.repository)
530
result.old_revno, result.old_revid = self.target.last_revision_info()
531
result.new_git_head = self._update_revisions(
532
stop_revision, overwrite=overwrite, graph=graph)
533
result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
535
result.new_revno, result.new_revid = self.target.last_revision_info()
539
class InterGitBranch(branch.GenericInterBranch):
540
"""InterBranch implementation that pulls between Git branches."""
543
class InterGitLocalRemoteBranch(InterGitBranch):
544
"""InterBranch that copies from a local to a remote git branch."""
547
def is_compatible(self, source, target):
548
from bzrlib.plugins.git.remote import RemoteGitBranch
549
return (isinstance(source, LocalGitBranch) and
550
isinstance(target, RemoteGitBranch))
552
def _basic_push(self, overwrite=False, stop_revision=None):
553
from dulwich.protocol import ZERO_SHA
554
result = GitBranchPushResult()
555
result.source_branch = self.source
556
result.target_branch = self.target
557
if stop_revision is None:
558
stop_revision = self.source.last_revision()
559
# FIXME: Check for diverged branches
560
def get_changed_refs(old_refs):
561
result.old_revid = self.target.lookup_foreign_revision_id(old_refs.get(self.target.ref, ZERO_SHA))
562
refs = { self.target.ref: self.source.repository.lookup_bzr_revision_id(stop_revision)[0] }
563
result.new_revid = stop_revision
564
for name, sha in self.source.repository._git.refs.as_dict("refs/tags").iteritems():
565
refs[tag_name_to_ref(name)] = sha
567
self.target.repository.send_pack(get_changed_refs,
568
self.source.repository._git.object_store.generate_pack_contents)
572
class InterGitRemoteLocalBranch(InterGitBranch):
573
"""InterBranch that copies from a remote to a local git branch."""
576
def is_compatible(self, source, target):
577
from bzrlib.plugins.git.remote import RemoteGitBranch
578
return (isinstance(source, RemoteGitBranch) and
579
isinstance(target, LocalGitBranch))
581
def _basic_push(self, overwrite=False, stop_revision=None):
582
result = branch.BranchPushResult()
583
result.source_branch = self.source
584
result.target_branch = self.target
585
result.old_revid = self.target.last_revision()
586
refs, stop_revision = self.update_refs(stop_revision)
587
self.target.generate_revision_history(stop_revision, result.old_revid)
588
self.update_tags(refs)
589
result.new_revid = self.target.last_revision()
592
def update_tags(self, refs):
593
for name, v in extract_tags(refs).iteritems():
594
revid = self.target.lookup_foreign_revision_id(v)
595
self.target.tags.set_tag(name, revid)
597
def update_refs(self, stop_revision=None):
598
interrepo = repository.InterRepository.get(self.source.repository,
599
self.target.repository)
600
if stop_revision is None:
601
refs = interrepo.fetch(branches=["HEAD"])
602
stop_revision = self.target.lookup_foreign_revision_id(refs["HEAD"])
604
refs = interrepo.fetch(revision_id=stop_revision)
605
return refs, stop_revision
607
def pull(self, stop_revision=None, overwrite=False,
608
possible_transports=None, run_hooks=True,local=False):
609
# This type of branch can't be bound.
611
raise errors.LocalRequiresBoundBranch()
612
result = GitPullResult()
613
result.source_branch = self.source
614
result.target_branch = self.target
615
result.old_revid = self.target.last_revision()
616
refs, stop_revision = self.update_refs(stop_revision)
617
self.target.generate_revision_history(stop_revision, result.old_revid)
618
self.update_tags(refs)
619
result.new_revid = self.target.last_revision()
623
class InterToGitBranch(branch.GenericInterBranch):
624
"""InterBranch implementation that pulls from Git into bzr."""
626
def __init__(self, source, target):
627
super(InterToGitBranch, self).__init__(source, target)
628
self.interrepo = repository.InterRepository.get(source.repository,
632
def _get_branch_formats_to_test():
636
def is_compatible(self, source, target):
637
return (not isinstance(source, GitBranch) and
638
isinstance(target, GitBranch))
640
def update_revisions(self, *args, **kwargs):
641
raise NoPushSupport()
643
def _get_new_refs(self, stop_revision=None):
644
if stop_revision is None:
645
stop_revision = self.source.last_revision()
646
main_ref = self.target.ref or "refs/heads/master"
647
refs = { main_ref: stop_revision }
648
for name, revid in self.source.tags.get_tag_dict().iteritems():
649
if self.source.repository.has_revision(revid):
650
refs[tag_name_to_ref(name)] = revid
651
return refs, main_ref
653
def pull(self, overwrite=False, stop_revision=None, local=False,
654
possible_transports=None):
655
from dulwich.protocol import ZERO_SHA
656
result = GitBranchPullResult()
657
result.source_branch = self.source
658
result.target_branch = self.target
659
new_refs, main_ref = self._get_new_refs(stop_revision)
660
def update_refs(old_refs):
661
refs = dict(old_refs)
662
# FIXME: Check for diverged branches
663
refs.update(new_refs)
665
old_refs, new_refs = self.interrepo.fetch_refs(update_refs)
666
result.old_revid = self.target.lookup_foreign_revision_id(
667
old_refs.get(main_ref, ZERO_SHA))
668
result.new_revid = new_refs[main_ref]
671
def push(self, overwrite=False, stop_revision=None,
672
_override_hook_source_branch=None):
673
from dulwich.protocol import ZERO_SHA
674
result = GitBranchPushResult()
675
result.source_branch = self.source
676
result.target_branch = self.target
677
new_refs, main_ref = self._get_new_refs(stop_revision)
678
def update_refs(old_refs):
679
refs = dict(old_refs)
680
# FIXME: Check for diverged branches
681
refs.update(new_refs)
683
old_refs, new_refs = self.interrepo.fetch_refs(update_refs)
684
result.old_revid = self.target.lookup_foreign_revision_id(
685
old_refs.get(main_ref, ZERO_SHA))
686
result.new_revid = new_refs[main_ref]
689
def lossy_push(self, stop_revision=None):
690
from dulwich.protocol import ZERO_SHA
691
result = GitBranchPushResult()
692
result.source_branch = self.source
693
result.target_branch = self.target
694
new_refs, main_ref = self._get_new_refs(stop_revision)
695
def update_refs(old_refs):
696
refs = dict(old_refs)
697
# FIXME: Check for diverged branches
698
refs.update(new_refs)
700
result.revidmap, old_refs, new_refs = self.interrepo.dfetch_refs(
702
result.old_revid = self.target.lookup_foreign_revision_id(
703
old_refs.get(self.target.ref, ZERO_SHA))
704
result.new_revid = self.target.lookup_foreign_revision_id(
709
branch.InterBranch.register_optimiser(InterGitRemoteLocalBranch)
710
branch.InterBranch.register_optimiser(InterFromGitBranch)
711
branch.InterBranch.register_optimiser(InterToGitBranch)
712
branch.InterBranch.register_optimiser(InterGitLocalRemoteBranch)
added
removed
branch.py
