To get this branch, use:
bzr branch
http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar
« back to all changes in this revision
Viewing changes to branch.py
- browse files at revision 0.200.1028
- compare with another revision
- download diff
- download tarball
- view history from revision 0.200.1028
- Committer: Jelmer Vernooij
- Date: 2010-09-02 19:34:29 UTC
- mto: (0.312.1 master) (6883.23.1 bundle-git)
- mto: This revision was merged to the branch mainline in revision 6960.
- Revision ID: jelmer@samba.org-20100902193429-pg9u1cf8l7krkad2
Fix imports of TestLoader on newer versions of bzr.
- files added:
- HACKING
- files removed:
- foreign
- files renamed:
- shamap.py => cache.py
- tests/test_ids.py => tests/test_mapping.py
- files modified:
- Makefile
added
removed
branch.py
1
1
# Copyright (C) 2007 Canonical Ltd
2
# Copyright (C) 2009-2010 Jelmer Vernooij <jelmer@samba.org>
2
3
#
3
4
# This program is free software; you can redistribute it and/or modify
4
5
# it under the terms of the GNU General Public License as published by
16
17
17
18
"""An adapter between a Git Branch and a Bazaar Branch"""
18
19
20
from dulwich.objects import (
21
Commit,
22
Tag,
23
)
24
19
25
from bzrlib import (
20
26
branch,
27
bzrdir,
21
28
config,
29
errors,
22
30
repository,
23
31
revision,
24
32
tag,
25
)
26
from bzrlib.decorators import needs_read_lock
27
from bzrlib.trace import mutter
28
29
from bzrlib.plugins.git.foreign import ForeignBranch
30
from bzrlib.plugins.git.errors import LightWeightCheckoutsNotSupported
31
32
from dulwich.objects import (
33
Commit,
34
Tag,
35
)
36
37
class GitTagDict(tag.BasicTags):
33
transport,
34
)
35
from bzrlib.decorators import (
36
needs_read_lock,
37
)
38
from bzrlib.revision import (
39
NULL_REVISION,
40
)
41
from bzrlib.trace import (
42
is_quiet,
43
mutter,
44
)
45
46
from bzrlib.plugins.git.config import (
47
GitBranchConfig,
48
)
49
from bzrlib.plugins.git.errors import (
50
NoPushSupport,
51
NoSuchRef,
52
)
53
from bzrlib.plugins.git.refs import (
54
ref_to_branch_name,
55
extract_tags,
56
tag_name_to_ref,
57
)
58
59
from bzrlib.foreign import ForeignBranch
60
61
62
class GitPullResult(branch.PullResult):
63
"""Result of a pull from a Git branch."""
64
65
def _lookup_revno(self, revid):
66
assert isinstance(revid, str), "was %r" % revid
67
# Try in source branch first, it'll be faster
68
return self.target_branch.revision_id_to_revno(revid)
69
70
@property
71
def old_revno(self):
72
return self._lookup_revno(self.old_revid)
73
74
@property
75
def new_revno(self):
76
return self._lookup_revno(self.new_revid)
77
78
79
class LocalGitTagDict(tag.BasicTags):
80
"""Dictionary with tags in a local repository."""
38
81
39
82
def __init__(self, branch):
40
83
self.branch = branch
42
85
43
86
def get_tag_dict(self):
44
87
ret = {}
45
for k,v in self.repository._git.tags.iteritems():
46
obj = self.repository._git.get_object(v)
88
for k,v in extract_tags(self.repository._git.get_refs()).iteritems():
89
try:
90
obj = self.repository._git[v]
91
except KeyError:
92
mutter("Tag %s points at unknown object %s, ignoring", v, obj)
93
continue
47
94
while isinstance(obj, Tag):
48
95
v = obj.object[1]
49
obj = self.repository._git.get_object(v)
96
obj = self.repository._git[v]
50
97
if not isinstance(obj, Commit):
51
mutter("Tag %s points at object %r that is not a commit, ignoring", k, obj)
98
mutter("Tag %s points at object %r that is not a commit, "
99
"ignoring", k, obj)
52
100
continue
53
ret[k] = self.branch.mapping.revision_id_foreign_to_bzr(v)
101
ret[k] = self.branch.lookup_foreign_revision_id(v)
54
102
return ret
55
103
104
def _set_tag_dict(self, to_dict):
105
extra = set(self.repository._git.get_refs().keys())
106
for k, revid in to_dict.iteritems():
107
name = tag_name_to_ref(k)
108
if name in extra:
109
extra.remove(name)
110
self.set_tag(k, revid)
111
for name in extra:
112
if name.startswith("refs/tags/"):
113
del self.repository._git[name]
114
56
115
def set_tag(self, name, revid):
57
self.repository._git.tags[name] = revid
58
59
60
class GitBranchConfig(config.BranchConfig):
61
"""BranchConfig that uses locations.conf in place of branch.conf"""
62
63
def __init__(self, branch):
64
config.BranchConfig.__init__(self, branch)
65
# do not provide a BranchDataConfig
66
self.option_sources = self.option_sources[0], self.option_sources[2]
67
68
def set_user_option(self, name, value, store=config.STORE_BRANCH, warn_masked=False):
69
"""Force local to True"""
70
config.BranchConfig.set_user_option(self, name, value, store=config.STORE_LOCATION, warn_masked=warn_masked)
116
self.repository._git.refs[tag_name_to_ref(name)], _ = \
117
self.branch.mapping.revision_id_bzr_to_foreign(revid)
118
119
120
class DictTagDict(LocalGitTagDict):
121
122
def __init__(self, branch, tags):
123
super(DictTagDict, self).__init__(branch)
124
self._tags = tags
125
126
def get_tag_dict(self):
127
return self._tags
71
128
72
129
73
130
class GitBranchFormat(branch.BranchFormat):
75
132
def get_format_description(self):
76
133
return 'Git Branch'
77
134
135
def network_name(self):
136
return "git"
137
78
138
def supports_tags(self):
79
139
return True
80
140
141
def get_foreign_tests_branch_factory(self):
142
from bzrlib.plugins.git.tests.test_branch import ForeignTestsBranchFactory
143
return ForeignTestsBranchFactory()
144
145
def make_tags(self, branch):
146
if getattr(branch.repository, "get_refs", None) is not None:
147
from bzrlib.plugins.git.remote import RemoteGitTagDict
148
return RemoteGitTagDict(branch)
149
else:
150
return LocalGitTagDict(branch)
151
152
153
class GitReadLock(object):
154
155
def __init__(self, unlock):
156
self.unlock = unlock
157
158
159
class GitWriteLock(object):
160
161
def __init__(self, unlock):
162
self.unlock = unlock
163
81
164
82
165
class GitBranch(ForeignBranch):
83
166
"""An adapter to git repositories for bzr Branch objects."""
84
167
85
def __init__(self, bzrdir, repository, name, head, lockfiles):
168
def __init__(self, bzrdir, repository, ref, lockfiles, tagsdict=None):
86
169
self.repository = repository
87
super(GitBranch, self).__init__(repository.get_mapping())
170
self._format = GitBranchFormat()
88
171
self.control_files = lockfiles
89
172
self.bzrdir = bzrdir
90
self.name = name
91
self.head = head
92
self.base = bzrdir.transport.base
93
self._format = GitBranchFormat()
94
95
def dpull(self, source, stop_revision=None):
96
if stop_revision is None:
97
stop_revision = source.last_revision()
98
# FIXME: Check for diverged branches
99
revidmap = self.repository.dfetch(source.repository, stop_revision)
100
self.head, self.mapping = self.mapping.revision_id_bzr_to_foreign(revidmap[stop_revision])
101
return revidmap
173
super(GitBranch, self).__init__(repository.get_mapping())
174
if tagsdict is not None:
175
self.tags = DictTagDict(self, tagsdict)
176
self.ref = ref
177
self.name = ref_to_branch_name(ref)
178
self._head = None
179
self.base = bzrdir.root_transport.base
180
181
def _get_checkout_format(self):
182
"""Return the most suitable metadir for a checkout of this branch.
183
Weaves are used if this branch's repository uses weaves.
184
"""
185
return bzrdir.format_registry.make_bzrdir("default")
186
187
def get_child_submit_format(self):
188
"""Return the preferred format of submissions to this branch."""
189
ret = self.get_config().get_user_option("child_submit_format")
190
if ret is not None:
191
return ret
192
return "git"
193
194
def _get_nick(self, local=False, possible_master_transports=None):
195
"""Find the nick name for this branch.
196
197
:return: Branch nick
198
"""
199
return self.name or "HEAD"
200
201
def _set_nick(self, nick):
202
raise NotImplementedError
203
204
nick = property(_get_nick, _set_nick)
205
206
def __repr__(self):
207
return "<%s(%r, %r)>" % (self.__class__.__name__, self.repository.base,
208
self.ref or "HEAD")
209
210
def generate_revision_history(self, revid, old_revid=None):
211
# FIXME: Check that old_revid is in the ancestry of revid
212
newhead, self.mapping = self.mapping.revision_id_bzr_to_foreign(revid)
213
self._set_head(newhead)
102
214
103
215
def lock_write(self):
104
216
self.control_files.lock_write()
217
return GitWriteLock(self.unlock)
105
218
106
219
def get_stacked_on_url(self):
107
220
# Git doesn't do stacking (yet...)
108
return None
221
raise errors.UnstackableBranchFormat(self._format, self.base)
109
222
110
223
def get_parent(self):
111
224
"""See Branch.get_parent()."""
225
# FIXME: Set "origin" url from .git/config ?
112
226
return None
113
227
114
228
def set_parent(self, url):
229
# FIXME: Set "origin" url in .git/config ?
115
230
pass
116
231
117
232
def lock_read(self):
118
233
self.control_files.lock_read()
234
return GitReadLock(self.unlock)
235
236
def is_locked(self):
237
return self.control_files.is_locked()
119
238
120
239
def unlock(self):
121
240
self.control_files.unlock()
123
242
def get_physical_lock_status(self):
124
243
return False
125
244
126
127
class LocalGitBranch(GitBranch):
128
129
245
@needs_read_lock
130
246
def last_revision(self):
131
247
# perhaps should escape this ?
132
248
if self.head is None:
133
249
return revision.NULL_REVISION
134
return self.mapping.revision_id_foreign_to_bzr(self.head)
135
136
def create_checkout(self, to_location, revision_id=None,
137
lightweight=False, accelerator_tree=None, hardlink=False):
250
return self.lookup_foreign_revision_id(self.head)
251
252
def _basic_push(self, target, overwrite=False, stop_revision=None):
253
return branch.InterBranch.get(self, target)._basic_push(
254
overwrite, stop_revision)
255
256
def lookup_foreign_revision_id(self, foreign_revid):
257
return self.repository.lookup_foreign_revision_id(foreign_revid,
258
self.mapping)
259
260
261
class LocalGitBranch(GitBranch):
262
"""A local Git branch."""
263
264
def __init__(self, bzrdir, repository, name, lockfiles, tagsdict=None):
265
super(LocalGitBranch, self).__init__(bzrdir, repository, name,
266
lockfiles, tagsdict)
267
refs = repository._git.get_refs()
268
if not (name in refs.keys() or "HEAD" in refs.keys()):
269
raise errors.NotBranchError(self.base)
270
271
def create_checkout(self, to_location, revision_id=None, lightweight=False,
272
accelerator_tree=None, hardlink=False):
138
273
if lightweight:
139
raise LightWeightCheckoutsNotSupported()
140
return self._create_heavyweight_checkout(to_location, revision_id, hardlink)
274
t = transport.get_transport(to_location)
275
t.ensure_base()
276
format = self._get_checkout_format()
277
checkout = format.initialize_on_transport(t)
278
from_branch = branch.BranchReferenceFormat().initialize(checkout,
279
self)
280
tree = checkout.create_workingtree(revision_id,
281
from_branch=from_branch, hardlink=hardlink)
282
return tree
283
else:
284
return self._create_heavyweight_checkout(to_location, revision_id,
285
hardlink)
141
286
142
def _create_heavyweight_checkout(self, to_location, revision_id=None,
287
def _create_heavyweight_checkout(self, to_location, revision_id=None,
143
288
hardlink=False):
144
289
"""Create a new heavyweight checkout of this branch.
145
290
148
293
:param hardlink: Whether to hardlink
149
294
:return: WorkingTree object of checkout.
150
295
"""
151
checkout_branch = BzrDir.create_branch_convenience(
152
to_location, force_new_tree=False, format=get_rich_root_format())
296
checkout_branch = bzrdir.BzrDir.create_branch_convenience(
297
to_location, force_new_tree=False)
153
298
checkout = checkout_branch.bzrdir
154
299
checkout_branch.bind(self)
155
# pull up to the specified revision_id to set the initial
300
# pull up to the specified revision_id to set the initial
156
301
# branch tip correctly, and seed it with history.
157
302
checkout_branch.pull(self, stop_revision=revision_id)
158
303
return checkout.create_workingtree(revision_id, hardlink=hardlink)
159
304
160
def _make_tags(self):
161
return GitTagDict(self)
162
163
305
def _gen_revision_history(self):
164
306
if self.head is None:
165
307
return []
166
ret = list(self.repository.iter_reverse_revision_history(self.last_revision()))
308
ret = list(self.repository.iter_reverse_revision_history(
309
self.last_revision()))
167
310
ret.reverse()
168
311
return ret
169
312
313
def _get_head(self):
314
try:
315
return self.repository._git.ref(self.ref or "HEAD")
316
except KeyError:
317
return None
318
319
def set_last_revision_info(self, revno, revid):
320
self.set_last_revision(revid)
321
322
def set_last_revision(self, revid):
323
(newhead, self.mapping) = self.repository.lookup_bzr_revision_id(revid)
324
self.head = newhead
325
326
def _set_head(self, value):
327
self._head = value
328
self.repository._git.refs[self.ref or "HEAD"] = self._head
329
self._clear_cached_state()
330
331
head = property(_get_head, _set_head)
332
170
333
def get_config(self):
171
334
return GitBranchConfig(self)
172
335
183
346
def supports_tags(self):
184
347
return True
185
348
186
def sprout(self, to_bzrdir, revision_id=None):
187
"""See Branch.sprout()."""
188
result = to_bzrdir.create_branch()
189
self.copy_content_into(result, revision_id=revision_id)
190
result.set_parent(self.bzrdir.root_transport.base)
191
return result
192
193
194
class InterGitGenericBranch(branch.InterBranch):
195
196
@classmethod
197
def is_compatible(self, source, target):
198
return isinstance(source, GitBranch)
199
200
def update_revisions(self, stop_revision=None, overwrite=False,
201
graph=None):
202
"""See InterBranch.update_revisions()."""
203
# TODO: stop_revision, overwrite
204
interrepo = repository.InterRepository.get(self.source.repository, self.target.repository)
205
self._last_revid = None
349
350
class GitBranchPullResult(branch.PullResult):
351
352
def __init__(self):
353
super(GitBranchPullResult, self).__init__()
354
self.new_git_head = None
355
self._old_revno = None
356
self._new_revno = None
357
358
def report(self, to_file):
359
if not is_quiet():
360
if self.old_revid == self.new_revid:
361
to_file.write('No revisions to pull.\n')
362
elif self.new_git_head is not None:
363
to_file.write('Now on revision %d (git sha: %s).\n' %
364
(self.new_revno, self.new_git_head))
365
else:
366
to_file.write('Now on revision %d.\n' % (self.new_revno,))
367
self._show_tag_conficts(to_file)
368
369
def _lookup_revno(self, revid):
370
assert isinstance(revid, str), "was %r" % revid
371
# Try in source branch first, it'll be faster
372
try:
373
return self.source_branch.revision_id_to_revno(revid)
374
except errors.NoSuchRevision:
375
# FIXME: Check using graph.find_distance_to_null() ?
376
return self.target_branch.revision_id_to_revno(revid)
377
378
def _get_old_revno(self):
379
if self._old_revno is not None:
380
return self._old_revno
381
return self._lookup_revno(self.old_revid)
382
383
def _set_old_revno(self, revno):
384
self._old_revno = revno
385
386
old_revno = property(_get_old_revno, _set_old_revno)
387
388
def _get_new_revno(self):
389
if self._new_revno is not None:
390
return self._new_revno
391
return self._lookup_revno(self.new_revid)
392
393
def _set_new_revno(self, revno):
394
self._new_revno = revno
395
396
new_revno = property(_get_new_revno, _set_new_revno)
397
398
399
class GitBranchPushResult(branch.BranchPushResult):
400
401
def _lookup_revno(self, revid):
402
assert isinstance(revid, str), "was %r" % revid
403
# Try in source branch first, it'll be faster
404
try:
405
return self.source_branch.revision_id_to_revno(revid)
406
except errors.NoSuchRevision:
407
# FIXME: Check using graph.find_distance_to_null() ?
408
return self.target_branch.revision_id_to_revno(revid)
409
410
@property
411
def old_revno(self):
412
return self._lookup_revno(self.old_revid)
413
414
@property
415
def new_revno(self):
416
return self._lookup_revno(self.new_revid)
417
418
419
class InterFromGitBranch(branch.GenericInterBranch):
420
"""InterBranch implementation that pulls from Git into bzr."""
421
422
@staticmethod
423
def _get_branch_formats_to_test():
424
return []
425
426
@classmethod
427
def _get_interrepo(self, source, target):
428
return repository.InterRepository.get(source.repository,
429
target.repository)
430
431
@classmethod
432
def is_compatible(cls, source, target):
433
return (isinstance(source, GitBranch) and
434
not isinstance(target, GitBranch) and
435
(getattr(cls._get_interrepo(source, target), "fetch_objects", None) is not None))
436
437
def _update_revisions(self, stop_revision=None, overwrite=False,
438
graph=None, limit=None):
439
"""Like InterBranch.update_revisions(), but with additions.
440
441
Compared to the `update_revisions()` below, this function takes a
442
`limit` argument that limits how many git commits will be converted
443
and returns the new git head.
444
"""
445
interrepo = self._get_interrepo(self.source, self.target)
206
446
def determine_wants(heads):
207
if not self.source.name in heads:
208
raise BzrError("No such remote branch '%s', found: %r" % (
209
self.source.name, heads.keys()))
210
head = heads[self.source.name]
211
self._last_revid = self.source.mapping.revision_id_foreign_to_bzr(head)
447
if self.source.ref is not None and not self.source.ref in heads:
448
raise NoSuchRef(self.source.ref, heads.keys())
449
if stop_revision is not None:
450
self._last_revid = stop_revision
451
head, mapping = self.source.repository.lookup_bzr_revision_id(
452
stop_revision)
453
else:
454
if self.source.ref is not None:
455
head = heads[self.source.ref]
456
else:
457
head = heads["HEAD"]
458
self._last_revid = self.source.lookup_foreign_revision_id(head)
212
459
if self.target.repository.has_revision(self._last_revid):
213
460
return []
214
461
return [head]
215
interrepo.fetch_objects(determine_wants, self.source.mapping)
216
self.target.set_last_revision(last_revid)
217
218
219
branch.InterBranch.register_optimiser(InterGitGenericBranch)
462
pack_hint, head, refs = interrepo.fetch_objects(
463
determine_wants, self.source.mapping, limit=limit)
464
if (pack_hint is not None and
465
self.target.repository._format.pack_compresses):
466
self.target.repository.pack(hint=pack_hint)
467
if head is not None:
468
self._last_revid = self.source.lookup_foreign_revision_id(head)
469
if overwrite:
470
prev_last_revid = None
471
else:
472
prev_last_revid = self.target.last_revision()
473
self.target.generate_revision_history(self._last_revid,
474
prev_last_revid)
475
return head
476
477
def update_revisions(self, stop_revision=None, overwrite=False,
478
graph=None):
479
"""See InterBranch.update_revisions()."""
480
self._update_revisions(stop_revision, overwrite, graph)
481
482
def pull(self, overwrite=False, stop_revision=None,
483
possible_transports=None, _hook_master=None, run_hooks=True,
484
_override_hook_target=None, local=False, limit=None):
485
"""See Branch.pull.
486
487
:param _hook_master: Private parameter - set the branch to
488
be supplied as the master to pull hooks.
489
:param run_hooks: Private parameter - if false, this branch
490
is being called because it's the master of the primary branch,
491
so it should not run its hooks.
492
:param _override_hook_target: Private parameter - set the branch to be
493
supplied as the target_branch to pull hooks.
494
:param limit: Only import this many revisons. `None`, the default,
495
means import all revisions.
496
"""
497
# This type of branch can't be bound.
498
if local:
499
raise errors.LocalRequiresBoundBranch()
500
result = GitBranchPullResult()
501
result.source_branch = self.source
502
if _override_hook_target is None:
503
result.target_branch = self.target
504
else:
505
result.target_branch = _override_hook_target
506
self.source.lock_read()
507
try:
508
# We assume that during 'pull' the target repository is closer than
509
# the source one.
510
graph = self.target.repository.get_graph(self.source.repository)
511
(result.old_revno, result.old_revid) = \
512
self.target.last_revision_info()
513
result.new_git_head = self._update_revisions(
514
stop_revision, overwrite=overwrite, graph=graph, limit=limit)
515
result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
516
overwrite)
517
(result.new_revno, result.new_revid) = \
518
self.target.last_revision_info()
519
if _hook_master:
520
result.master_branch = _hook_master
521
result.local_branch = result.target_branch
522
else:
523
result.master_branch = result.target_branch
524
result.local_branch = None
525
if run_hooks:
526
for hook in branch.Branch.hooks['post_pull']:
527
hook(result)
528
finally:
529
self.source.unlock()
530
return result
531
532
def _basic_push(self, overwrite=False, stop_revision=None):
533
result = branch.BranchPushResult()
534
result.source_branch = self.source
535
result.target_branch = self.target
536
graph = self.target.repository.get_graph(self.source.repository)
537
result.old_revno, result.old_revid = self.target.last_revision_info()
538
result.new_git_head = self._update_revisions(
539
stop_revision, overwrite=overwrite, graph=graph)
540
result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
541
overwrite)
542
result.new_revno, result.new_revid = self.target.last_revision_info()
543
return result
544
545
546
class InterGitBranch(branch.GenericInterBranch):
547
"""InterBranch implementation that pulls between Git branches."""
548
549
550
class InterGitLocalRemoteBranch(InterGitBranch):
551
"""InterBranch that copies from a local to a remote git branch."""
552
553
@staticmethod
554
def _get_branch_formats_to_test():
555
return []
556
557
@classmethod
558
def is_compatible(self, source, target):
559
from bzrlib.plugins.git.remote import RemoteGitBranch
560
return (isinstance(source, LocalGitBranch) and
561
isinstance(target, RemoteGitBranch))
562
563
def _basic_push(self, overwrite=False, stop_revision=None):
564
from dulwich.protocol import ZERO_SHA
565
result = GitBranchPushResult()
566
result.source_branch = self.source
567
result.target_branch = self.target
568
if stop_revision is None:
569
stop_revision = self.source.last_revision()
570
# FIXME: Check for diverged branches
571
def get_changed_refs(old_refs):
572
result.old_revid = self.target.lookup_foreign_revision_id(old_refs.get(self.target.ref, ZERO_SHA))
573
refs = { self.target.ref: self.source.repository.lookup_bzr_revision_id(stop_revision)[0] }
574
result.new_revid = stop_revision
575
for name, sha in self.source.repository._git.refs.as_dict("refs/tags").iteritems():
576
refs[tag_name_to_ref(name)] = sha
577
return refs
578
self.target.repository.send_pack(get_changed_refs,
579
self.source.repository._git.object_store.generate_pack_contents)
580
return result
581
582
583
class InterGitRemoteLocalBranch(InterGitBranch):
584
"""InterBranch that copies from a remote to a local git branch."""
585
586
@staticmethod
587
def _get_branch_formats_to_test():
588
return []
589
590
@classmethod
591
def is_compatible(self, source, target):
592
from bzrlib.plugins.git.remote import RemoteGitBranch
593
return (isinstance(source, RemoteGitBranch) and
594
isinstance(target, LocalGitBranch))
595
596
def _basic_push(self, overwrite=False, stop_revision=None):
597
result = branch.BranchPushResult()
598
result.source_branch = self.source
599
result.target_branch = self.target
600
result.old_revid = self.target.last_revision()
601
refs, stop_revision = self.update_refs(stop_revision)
602
self.target.generate_revision_history(stop_revision, result.old_revid)
603
self.update_tags(refs)
604
result.new_revid = self.target.last_revision()
605
return result
606
607
def update_tags(self, refs):
608
for name, v in extract_tags(refs).iteritems():
609
revid = self.target.lookup_foreign_revision_id(v)
610
self.target.tags.set_tag(name, revid)
611
612
def update_refs(self, stop_revision=None):
613
interrepo = repository.InterRepository.get(self.source.repository,
614
self.target.repository)
615
if stop_revision is None:
616
refs = interrepo.fetch(branches=["HEAD"])
617
stop_revision = self.target.lookup_foreign_revision_id(refs["HEAD"])
618
else:
619
refs = interrepo.fetch(revision_id=stop_revision)
620
return refs, stop_revision
621
622
def pull(self, stop_revision=None, overwrite=False,
623
possible_transports=None, run_hooks=True,local=False):
624
# This type of branch can't be bound.
625
if local:
626
raise errors.LocalRequiresBoundBranch()
627
result = GitPullResult()
628
result.source_branch = self.source
629
result.target_branch = self.target
630
result.old_revid = self.target.last_revision()
631
refs, stop_revision = self.update_refs(stop_revision)
632
self.target.generate_revision_history(stop_revision, result.old_revid)
633
self.update_tags(refs)
634
result.new_revid = self.target.last_revision()
635
return result
636
637
638
class InterToGitBranch(branch.GenericInterBranch):
639
"""InterBranch implementation that pulls from Git into bzr."""
640
641
def __init__(self, source, target):
642
super(InterToGitBranch, self).__init__(source, target)
643
self.interrepo = repository.InterRepository.get(source.repository,
644
target.repository)
645
646
@staticmethod
647
def _get_branch_formats_to_test():
648
return []
649
650
@classmethod
651
def is_compatible(self, source, target):
652
return (not isinstance(source, GitBranch) and
653
isinstance(target, GitBranch))
654
655
def update_revisions(self, *args, **kwargs):
656
raise NoPushSupport()
657
658
def _get_new_refs(self, stop_revision=None):
659
if stop_revision is None:
660
stop_revision = self.source.last_revision()
661
assert type(stop_revision) is str
662
main_ref = self.target.ref or "refs/heads/master"
663
refs = { main_ref: (None, stop_revision) }
664
for name, revid in self.source.tags.get_tag_dict().iteritems():
665
if self.source.repository.has_revision(revid):
666
refs[tag_name_to_ref(name)] = (None, revid)
667
return refs, main_ref
668
669
def pull(self, overwrite=False, stop_revision=None, local=False,
670
possible_transports=None):
671
from dulwich.protocol import ZERO_SHA
672
result = GitBranchPullResult()
673
result.source_branch = self.source
674
result.target_branch = self.target
675
new_refs, main_ref = self._get_new_refs(stop_revision)
676
def update_refs(old_refs):
677
refs = dict(old_refs)
678
# FIXME: Check for diverged branches
679
refs.update(new_refs)
680
return refs
681
old_refs, new_refs = self.interrepo.fetch_refs(update_refs)
682
result.old_revid = self.target.lookup_foreign_revision_id(
683
old_refs.get(main_ref, ZERO_SHA))
684
result.new_revid = new_refs[main_ref]
685
return result
686
687
def push(self, overwrite=False, stop_revision=None,
688
_override_hook_source_branch=None):
689
from dulwich.protocol import ZERO_SHA
690
result = GitBranchPushResult()
691
result.source_branch = self.source
692
result.target_branch = self.target
693
new_refs, main_ref = self._get_new_refs(stop_revision)
694
def update_refs(old_refs):
695
refs = dict(old_refs)
696
# FIXME: Check for diverged branches
697
refs.update(new_refs)
698
return refs
699
old_refs, new_refs = self.interrepo.fetch_refs(update_refs)
700
result.old_revid = self.target.lookup_foreign_revision_id(
701
old_refs.get(main_ref, ZERO_SHA))
702
result.new_revid = new_refs[main_ref]
703
return result
704
705
def lossy_push(self, stop_revision=None):
706
result = GitBranchPushResult()
707
result.source_branch = self.source
708
result.target_branch = self.target
709
new_refs, main_ref = self._get_new_refs(stop_revision)
710
def update_refs(old_refs):
711
refs = dict(old_refs)
712
# FIXME: Check for diverged branches
713
refs.update(new_refs)
714
return refs
715
result.revidmap, old_refs, new_refs = self.interrepo.dfetch_refs(
716
update_refs)
717
result.old_revid = old_refs.get(self.target.ref, (None, NULL_REVISION))[1]
718
result.new_revid = new_refs[main_ref][1]
719
return result
720
721
722
branch.InterBranch.register_optimiser(InterGitRemoteLocalBranch)
723
branch.InterBranch.register_optimiser(InterFromGitBranch)
724
branch.InterBranch.register_optimiser(InterToGitBranch)
725
branch.InterBranch.register_optimiser(InterGitLocalRemoteBranch)
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0