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