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.1379
- compare with another revision
- download diff
- download tarball
- view history from revision 0.200.1379
- Committer: Jelmer Vernooij
- Date: 2011-09-13 02:18:15 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-20110913021815-87hgx97v3vyurcf0
Escape slashes.
- files added:
- .testr.conf
- files removed:
- inventory.py
- files modified:
- .bzrignore
added
removed
branch.py
17
17
18
18
"""An adapter between a Git Branch and a Bazaar Branch"""
19
19
20
from collections import defaultdict
21
20
22
from dulwich.objects import (
21
23
Commit,
22
24
Tag,
25
ZERO_SHA,
23
26
)
24
27
25
28
from bzrlib import (
27
30
bzrdir,
28
31
config,
29
32
errors,
30
repository,
33
repository as _mod_repository,
31
34
revision,
32
35
tag,
33
36
transport,
51
54
NoSuchRef,
52
55
)
53
56
from bzrlib.plugins.git.refs import (
57
extract_tags,
58
is_tag,
54
59
ref_to_branch_name,
55
extract_tags,
60
ref_to_tag_name,
56
61
tag_name_to_ref,
57
62
)
63
from bzrlib.plugins.git.unpeel_map import (
64
UnpeelMap,
65
)
58
66
59
67
from bzrlib.foreign import ForeignBranch
60
68
65
73
def _lookup_revno(self, revid):
66
74
assert isinstance(revid, str), "was %r" % revid
67
75
# Try in source branch first, it'll be faster
68
return self.target_branch.revision_id_to_revno(revid)
76
self.target_branch.lock_read()
77
try:
78
return self.target_branch.revision_id_to_revno(revid)
79
finally:
80
self.target_branch.unlock()
69
81
70
82
@property
71
83
def old_revno(self):
76
88
return self._lookup_revno(self.new_revid)
77
89
78
90
79
class LocalGitTagDict(tag.BasicTags):
80
"""Dictionary with tags in a local repository."""
91
class GitTags(tag.BasicTags):
92
"""Ref-based tag dictionary."""
81
93
82
94
def __init__(self, branch):
83
95
self.branch = branch
84
96
self.repository = branch.repository
85
97
98
def get_refs(self):
99
raise NotImplementedError(self.get_refs)
100
101
def _iter_tag_refs(self, refs):
102
raise NotImplementedError(self._iter_tag_refs)
103
104
def _merge_to_git(self, to_tags, refs, overwrite=False):
105
target_repo = to_tags.repository
106
conflicts = []
107
for k, v in refs.iteritems():
108
if not is_tag(k):
109
continue
110
if overwrite or not k in target_repo._git.refs:
111
target_repo._git.refs[k] = v
112
elif target_repo._git.refs[k] == v:
113
pass
114
else:
115
conflicts.append((ref_to_tag_name(k), v, target_repo.refs[k]))
116
return conflicts
117
118
def _merge_to_non_git(self, to_tags, refs, overwrite=False):
119
unpeeled_map = defaultdict(set)
120
conflicts = []
121
result = dict(to_tags.get_tag_dict())
122
for n, peeled, unpeeled, bzr_revid in self._iter_tag_refs(refs):
123
if unpeeled is not None:
124
unpeeled_map[peeled].add(unpeeled)
125
if n not in result or overwrite:
126
result[n] = bzr_revid
127
elif result[n] == bzr_revid:
128
pass
129
else:
130
conflicts.append((n, result[n], bzr_revid))
131
to_tags._set_tag_dict(result)
132
if len(unpeeled_map) > 0:
133
map_file = UnpeelMap.from_repository(to_tags.branch.repository)
134
map_file.update(unpeeled_map)
135
map_file.save_in_repository(to_tags.branch.repository)
136
return conflicts
137
138
def merge_to(self, to_tags, overwrite=False, ignore_master=False,
139
source_refs=None):
140
"""See Tags.merge_to."""
141
if source_refs is None:
142
source_refs = self.get_refs()
143
if self == to_tags:
144
return
145
if isinstance(to_tags, GitTags):
146
return self._merge_to_git(to_tags, source_refs,
147
overwrite=overwrite)
148
else:
149
if ignore_master:
150
master = None
151
else:
152
master = to_tags.branch.get_master_branch()
153
conflicts = self._merge_to_non_git(to_tags, source_refs,
154
overwrite=overwrite)
155
if master is not None:
156
conflicts += self.merge_to(master.tags, overwrite=overwrite,
157
source_refs=source_refs,
158
ignore_master=ignore_master)
159
return conflicts
160
86
161
def get_tag_dict(self):
87
162
ret = {}
88
for k,v in extract_tags(self.repository._git.get_refs()).iteritems():
163
refs = self.get_refs()
164
for (name, peeled, unpeeled, bzr_revid) in self._iter_tag_refs(refs):
165
ret[name] = bzr_revid
166
return ret
167
168
169
class LocalGitTagDict(GitTags):
170
"""Dictionary with tags in a local repository."""
171
172
def __init__(self, branch):
173
super(LocalGitTagDict, self).__init__(branch)
174
self.refs = self.repository._git.refs
175
176
def get_refs(self):
177
return self.repository._git.get_refs()
178
179
def _iter_tag_refs(self, refs):
180
"""Iterate over the tag refs.
181
182
:param refs: Refs dictionary (name -> git sha1)
183
:return: iterator over (name, peeled_sha1, unpeeled_sha1, bzr_revid)
184
"""
185
for k, (peeled, unpeeled) in extract_tags(refs).iteritems():
89
186
try:
90
obj = self.repository._git[v]
187
obj = self.repository._git[peeled]
91
188
except KeyError:
92
mutter("Tag %s points at unknown object %s, ignoring", v, obj)
189
mutter("Tag %s points at unknown object %s, ignoring", peeled,
190
peeled)
93
191
continue
192
# FIXME: this shouldn't really be necessary, the repository
193
# already should have these unpeeled.
94
194
while isinstance(obj, Tag):
95
v = obj.object[1]
96
obj = self.repository._git[v]
195
peeled = obj.object[1]
196
obj = self.repository._git[peeled]
97
197
if not isinstance(obj, Commit):
98
198
mutter("Tag %s points at object %r that is not a commit, "
99
199
"ignoring", k, obj)
100
200
continue
101
ret[k] = self.branch.lookup_foreign_revision_id(v)
102
return ret
201
yield (k, peeled, unpeeled,
202
self.branch.lookup_foreign_revision_id(peeled))
103
203
104
204
def _set_tag_dict(self, to_dict):
105
extra = set(self.repository._git.get_refs().keys())
205
extra = set(self.get_refs().keys())
106
206
for k, revid in to_dict.iteritems():
107
207
name = tag_name_to_ref(k)
108
208
if name in extra:
109
209
extra.remove(name)
110
210
self.set_tag(k, revid)
111
211
for name in extra:
112
if name.startswith("refs/tags/"):
212
if is_tag(name):
113
213
del self.repository._git[name]
114
214
115
215
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):
216
try:
217
git_sha, mapping = self.branch.lookup_bzr_revision_id(revid)
218
except errors.NoSuchRevision:
219
raise errors.GhostTagsNotSupported(self)
220
self.refs[tag_name_to_ref(name)] = git_sha
221
222
223
class DictTagDict(tag.BasicTags):
121
224
122
225
def __init__(self, branch, tags):
123
226
super(DictTagDict, self).__init__(branch)
127
230
return self._tags
128
231
129
232
233
class GitSymrefBranchFormat(branch.BranchFormat):
234
235
def get_format_description(self):
236
return 'Git Symbolic Reference Branch'
237
238
def network_name(self):
239
return "git"
240
241
def get_reference(self, controldir, name=None):
242
return controldir.get_branch_reference(name)
243
244
def set_reference(self, controldir, name, target):
245
return controldir.set_branch_reference(name, target)
246
247
130
248
class GitBranchFormat(branch.BranchFormat):
131
249
132
250
def get_format_description(self):
138
256
def supports_tags(self):
139
257
return True
140
258
259
def supports_leaving_lock(self):
260
return False
261
262
def supports_tags_referencing_ghosts(self):
263
return False
264
265
def tags_are_versioned(self):
266
return False
267
268
@property
269
def _matchingbzrdir(self):
270
from bzrlib.plugins.git.dir import LocalGitControlDirFormat
271
return LocalGitControlDirFormat()
272
141
273
def get_foreign_tests_branch_factory(self):
142
274
from bzrlib.plugins.git.tests.test_branch import ForeignTestsBranchFactory
143
275
return ForeignTestsBranchFactory()
149
281
else:
150
282
return LocalGitTagDict(branch)
151
283
284
def initialize(self, a_bzrdir, name=None, repository=None,
285
append_revisions_only=None):
286
from bzrlib.plugins.git.dir import LocalGitDir
287
if not isinstance(a_bzrdir, LocalGitDir):
288
raise errors.IncompatibleFormat(self, a_bzrdir._format)
289
return a_bzrdir.create_branch(repository=repository, name=name,
290
append_revisions_only=append_revisions_only)
291
152
292
153
293
class GitReadLock(object):
154
294
159
299
class GitWriteLock(object):
160
300
161
301
def __init__(self, unlock):
302
self.branch_token = None
162
303
self.unlock = unlock
163
304
164
305
165
306
class GitBranch(ForeignBranch):
166
307
"""An adapter to git repositories for bzr Branch objects."""
167
308
309
@property
310
def control_transport(self):
311
return self.bzrdir.control_transport
312
168
313
def __init__(self, bzrdir, repository, ref, lockfiles, tagsdict=None):
314
self.base = bzrdir.root_transport.base
169
315
self.repository = repository
170
316
self._format = GitBranchFormat()
171
317
self.control_files = lockfiles
172
318
self.bzrdir = bzrdir
319
self._lock_mode = None
320
self._lock_count = 0
173
321
super(GitBranch, self).__init__(repository.get_mapping())
174
322
if tagsdict is not None:
175
323
self.tags = DictTagDict(self, tagsdict)
176
324
self.ref = ref
177
self.name = ref_to_branch_name(ref)
325
try:
326
self.name = ref_to_branch_name(ref)
327
except ValueError:
328
self.name = None
178
329
self._head = None
179
self.base = bzrdir.root_transport.base
180
330
181
def _get_checkout_format(self):
331
def _get_checkout_format(self, lightweight=False):
182
332
"""Return the most suitable metadir for a checkout of this branch.
183
333
Weaves are used if this branch's repository uses weaves.
184
334
"""
205
355
206
356
def __repr__(self):
207
357
return "<%s(%r, %r)>" % (self.__class__.__name__, self.repository.base,
208
self.ref or "HEAD")
358
self.name)
209
359
210
360
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)
361
if revid == NULL_REVISION:
362
newhead = ZERO_SHA
363
else:
364
# FIXME: Check that old_revid is in the ancestry of revid
365
newhead, self.mapping = self.repository.lookup_bzr_revision_id(revid)
366
if self.mapping is None:
367
raise AssertionError
213
368
self._set_head(newhead)
214
369
215
def lock_write(self):
216
self.control_files.lock_write()
370
def lock_write(self, token=None):
371
if token is not None:
372
raise errors.TokenLockingNotSupported(self)
373
if self._lock_mode:
374
if self._lock_mode == 'r':
375
raise errors.ReadOnlyError(self)
376
self._lock_count += 1
377
else:
378
self._lock_mode = 'w'
379
self._lock_count = 1
380
self.repository.lock_write()
217
381
return GitWriteLock(self.unlock)
218
382
219
383
def get_stacked_on_url(self):
230
394
pass
231
395
232
396
def lock_read(self):
233
self.control_files.lock_read()
397
if self._lock_mode:
398
assert self._lock_mode in ('r', 'w')
399
self._lock_count += 1
400
else:
401
self._lock_mode = 'r'
402
self._lock_count = 1
403
self.repository.lock_read()
234
404
return GitReadLock(self.unlock)
235
405
406
def peek_lock_mode(self):
407
return self._lock_mode
408
236
409
def is_locked(self):
237
return self.control_files.is_locked()
410
return (self._lock_mode is not None)
238
411
239
412
def unlock(self):
240
self.control_files.unlock()
413
"""See Branch.unlock()."""
414
self._lock_count -= 1
415
if self._lock_count == 0:
416
self._lock_mode = None
417
self._clear_cached_state()
418
self.repository.unlock()
241
419
242
420
def get_physical_lock_status(self):
243
421
return False
265
443
class LocalGitBranch(GitBranch):
266
444
"""A local Git branch."""
267
445
268
def __init__(self, bzrdir, repository, name, lockfiles, tagsdict=None):
269
super(LocalGitBranch, self).__init__(bzrdir, repository, name,
446
def __init__(self, bzrdir, repository, ref, lockfiles, tagsdict=None):
447
super(LocalGitBranch, self).__init__(bzrdir, repository, ref,
270
448
lockfiles, tagsdict)
271
449
refs = repository._git.get_refs()
272
if not (name in refs.keys() or "HEAD" in refs.keys()):
450
if not (ref in refs.keys() or "HEAD" in refs.keys()):
273
451
raise errors.NotBranchError(self.base)
274
452
275
453
def create_checkout(self, to_location, revision_id=None, lightweight=False,
277
455
if lightweight:
278
456
t = transport.get_transport(to_location)
279
457
t.ensure_base()
280
format = self._get_checkout_format()
458
format = self._get_checkout_format(lightweight=True)
281
459
checkout = format.initialize_on_transport(t)
282
460
from_branch = branch.BranchReferenceFormat().initialize(checkout,
283
461
self)
298
476
:return: WorkingTree object of checkout.
299
477
"""
300
478
checkout_branch = bzrdir.BzrDir.create_branch_convenience(
301
to_location, force_new_tree=False)
479
to_location, force_new_tree=False,
480
format=self._get_checkout_format(lightweight=False))
302
481
checkout = checkout_branch.bzrdir
303
482
checkout_branch.bind(self)
304
483
# pull up to the specified revision_id to set the initial
309
488
def _gen_revision_history(self):
310
489
if self.head is None:
311
490
return []
312
ret = list(self.repository.iter_reverse_revision_history(
313
self.last_revision()))
491
graph = self.repository.get_graph()
492
ret = list(graph.iter_lefthand_ancestry(self.last_revision(),
493
(revision.NULL_REVISION, )))
314
494
ret.reverse()
315
495
return ret
316
496
320
500
except KeyError:
321
501
return None
322
502
323
def set_last_revision_info(self, revno, revid):
324
self.set_last_revision(revid)
503
def _read_last_revision_info(self):
504
last_revid = self.last_revision()
505
graph = self.repository.get_graph()
506
revno = graph.find_distance_to_null(last_revid,
507
[(revision.NULL_REVISION, 0)])
508
return revno, last_revid
509
510
def set_last_revision_info(self, revno, revision_id):
511
self.set_last_revision(revision_id)
512
self._last_revision_info_cache = revno, revision_id
325
513
326
514
def set_last_revision(self, revid):
327
(newhead, self.mapping) = self.repository.lookup_bzr_revision_id(revid)
328
self.head = newhead
515
if not revid or not isinstance(revid, basestring):
516
raise errors.InvalidRevisionId(revision_id=revid, branch=self)
517
if revid == NULL_REVISION:
518
newhead = ZERO_SHA
519
else:
520
(newhead, self.mapping) = self.repository.lookup_bzr_revision_id(revid)
521
if self.mapping is None:
522
raise AssertionError
523
self._set_head(newhead)
329
524
330
525
def _set_head(self, value):
331
526
self._head = value
351
546
return True
352
547
353
548
549
def _quick_lookup_revno(local_branch, remote_branch, revid):
550
assert isinstance(revid, str), "was %r" % revid
551
# Try in source branch first, it'll be faster
552
local_branch.lock_read()
553
try:
554
try:
555
return local_branch.revision_id_to_revno(revid)
556
except errors.NoSuchRevision:
557
graph = local_branch.repository.get_graph()
558
try:
559
return graph.find_distance_to_null(revid,
560
[(revision.NULL_REVISION, 0)])
561
except errors.GhostRevisionsHaveNoRevno:
562
# FIXME: Check using graph.find_distance_to_null() ?
563
remote_branch.lock_read()
564
try:
565
return remote_branch.revision_id_to_revno(revid)
566
finally:
567
remote_branch.unlock()
568
finally:
569
local_branch.unlock()
570
571
354
572
class GitBranchPullResult(branch.PullResult):
355
573
356
574
def __init__(self):
371
589
self._show_tag_conficts(to_file)
372
590
373
591
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)
592
return _quick_lookup_revno(self.target_branch, self.source_branch,
593
revid)
381
594
382
595
def _get_old_revno(self):
383
596
if self._old_revno is not None:
403
616
class GitBranchPushResult(branch.BranchPushResult):
404
617
405
618
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)
619
return _quick_lookup_revno(self.source_branch, self.target_branch,
620
revid)
413
621
414
622
@property
415
623
def old_revno(self):
417
625
418
626
@property
419
627
def new_revno(self):
628
new_original_revno = getattr(self, "new_original_revno", None)
629
if new_original_revno:
630
return new_original_revno
631
if getattr(self, "new_original_revid", None) is not None:
632
return self._lookup_revno(self.new_original_revid)
420
633
return self._lookup_revno(self.new_revid)
421
634
422
635
425
638
426
639
@staticmethod
427
640
def _get_branch_formats_to_test():
428
return []
641
try:
642
default_format = branch.format_registry.get_default()
643
except AttributeError:
644
default_format = branch.BranchFormat._default_format
645
return [
646
(GitBranchFormat(), GitBranchFormat()),
647
(GitBranchFormat(), default_format)]
429
648
430
649
@classmethod
431
650
def _get_interrepo(self, source, target):
432
return repository.InterRepository.get(source.repository,
433
target.repository)
651
return _mod_repository.InterRepository.get(source.repository, target.repository)
434
652
435
653
@classmethod
436
654
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
"""
655
if not isinstance(source, GitBranch):
656
return False
657
if isinstance(target, GitBranch):
658
# InterLocalGitRemoteGitBranch or InterToGitBranch should be used
659
return False
660
if getattr(cls._get_interrepo(source, target), "fetch_objects", None) is None:
661
# fetch_objects is necessary for this to work
662
return False
663
return True
664
665
def fetch(self, stop_revision=None, fetch_tags=None, limit=None):
666
self.fetch_objects(stop_revision, fetch_tags=fetch_tags, limit=limit)
667
668
def fetch_objects(self, stop_revision, fetch_tags, limit=None):
449
669
interrepo = self._get_interrepo(self.source, self.target)
670
if fetch_tags is None:
671
c = self.source.get_config()
672
fetch_tags = c.get_user_option_as_bool('branch.fetch_tags')
450
673
def determine_wants(heads):
451
674
if self.source.ref is not None and not self.source.ref in heads:
452
675
raise NoSuchRef(self.source.ref, heads.keys())
453
if stop_revision is not None:
454
self._last_revid = stop_revision
455
head, mapping = self.source.repository.lookup_bzr_revision_id(
456
stop_revision)
457
else:
676
677
if stop_revision is None:
458
678
if self.source.ref is not None:
459
679
head = heads[self.source.ref]
460
680
else:
461
681
head = heads["HEAD"]
462
682
self._last_revid = self.source.lookup_foreign_revision_id(head)
463
if self.target.repository.has_revision(self._last_revid):
464
return []
465
return [head]
683
else:
684
self._last_revid = stop_revision
685
real = interrepo.get_determine_wants_revids(
686
[self._last_revid], include_tags=fetch_tags)
687
return real(heads)
466
688
pack_hint, head, refs = interrepo.fetch_objects(
467
689
determine_wants, self.source.mapping, limit=limit)
468
690
if (pack_hint is not None and
469
691
self.target.repository._format.pack_compresses):
470
692
self.target.repository.pack(hint=pack_hint)
471
if head is not None:
472
self._last_revid = self.source.lookup_foreign_revision_id(head)
693
return head, refs
694
695
def _update_revisions(self, stop_revision=None, overwrite=False):
696
head, refs = self.fetch_objects(stop_revision, fetch_tags=None)
473
697
if overwrite:
474
698
prev_last_revid = None
475
699
else:
476
700
prev_last_revid = self.target.last_revision()
477
701
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)
702
prev_last_revid, self.source)
703
return head, refs
485
704
486
705
def pull(self, overwrite=False, stop_revision=None,
487
706
possible_transports=None, _hook_master=None, run_hooks=True,
488
_override_hook_target=None, local=False, limit=None):
707
_override_hook_target=None, local=False):
489
708
"""See Branch.pull.
490
709
491
710
:param _hook_master: Private parameter - set the branch to
495
714
so it should not run its hooks.
496
715
:param _override_hook_target: Private parameter - set the branch to be
497
716
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
717
"""
501
718
# This type of branch can't be bound.
502
719
if local:
509
726
result.target_branch = _override_hook_target
510
727
self.source.lock_read()
511
728
try:
512
# We assume that during 'pull' the target repository is closer than
513
# the source one.
514
graph = self.target.repository.get_graph(self.source.repository)
515
(result.old_revno, result.old_revid) = \
516
self.target.last_revision_info()
517
result.new_git_head = self._update_revisions(
518
stop_revision, overwrite=overwrite, graph=graph, limit=limit)
519
result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
520
overwrite)
521
(result.new_revno, result.new_revid) = \
522
self.target.last_revision_info()
523
if _hook_master:
524
result.master_branch = _hook_master
525
result.local_branch = result.target_branch
526
else:
527
result.master_branch = result.target_branch
528
result.local_branch = None
529
if run_hooks:
530
for hook in branch.Branch.hooks['post_pull']:
531
hook(result)
729
self.target.lock_write()
730
try:
731
# We assume that during 'pull' the target repository is closer than
732
# the source one.
733
(result.old_revno, result.old_revid) = \
734
self.target.last_revision_info()
735
result.new_git_head, remote_refs = self._update_revisions(
736
stop_revision, overwrite=overwrite)
737
result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
738
overwrite)
739
(result.new_revno, result.new_revid) = \
740
self.target.last_revision_info()
741
if _hook_master:
742
result.master_branch = _hook_master
743
result.local_branch = result.target_branch
744
else:
745
result.master_branch = result.target_branch
746
result.local_branch = None
747
if run_hooks:
748
for hook in branch.Branch.hooks['post_pull']:
749
hook(result)
750
finally:
751
self.target.unlock()
532
752
finally:
533
753
self.source.unlock()
534
754
return result
537
757
result = branch.BranchPushResult()
538
758
result.source_branch = self.source
539
759
result.target_branch = self.target
540
graph = self.target.repository.get_graph(self.source.repository)
541
760
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)
761
result.new_git_head, remote_refs = self._update_revisions(
762
stop_revision, overwrite=overwrite)
544
763
result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
545
764
overwrite)
546
765
result.new_revno, result.new_revid = self.target.last_revision_info()
551
770
"""InterBranch implementation that pulls between Git branches."""
552
771
553
772
554
class InterGitLocalRemoteBranch(InterGitBranch):
773
class InterLocalGitRemoteGitBranch(InterGitBranch):
555
774
"""InterBranch that copies from a local to a remote git branch."""
556
775
557
776
@staticmethod
558
777
def _get_branch_formats_to_test():
778
# FIXME
559
779
return []
560
780
561
781
@classmethod
565
785
isinstance(target, RemoteGitBranch))
566
786
567
787
def _basic_push(self, overwrite=False, stop_revision=None):
568
from dulwich.protocol import ZERO_SHA
569
788
result = GitBranchPushResult()
570
789
result.source_branch = self.source
571
790
result.target_branch = self.target
573
792
stop_revision = self.source.last_revision()
574
793
# FIXME: Check for diverged branches
575
794
def get_changed_refs(old_refs):
576
result.old_revid = self.target.lookup_foreign_revision_id(old_refs.get(self.target.ref, ZERO_SHA))
795
old_ref = old_refs.get(self.target.ref, ZERO_SHA)
796
result.old_revid = self.target.lookup_foreign_revision_id(old_ref)
577
797
refs = { self.target.ref: self.source.repository.lookup_bzr_revision_id(stop_revision)[0] }
578
798
result.new_revid = stop_revision
579
799
for name, sha in self.source.repository._git.refs.as_dict("refs/tags").iteritems():
584
804
return result
585
805
586
806
587
class InterGitRemoteLocalBranch(InterGitBranch):
807
class InterGitLocalGitBranch(InterGitBranch):
588
808
"""InterBranch that copies from a remote to a local git branch."""
589
809
590
810
@staticmethod
591
811
def _get_branch_formats_to_test():
812
# FIXME
592
813
return []
593
814
594
815
@classmethod
595
816
def is_compatible(self, source, target):
596
from bzrlib.plugins.git.remote import RemoteGitBranch
597
return (isinstance(source, RemoteGitBranch) and
817
return (isinstance(source, GitBranch) and
598
818
isinstance(target, LocalGitBranch))
599
819
600
820
def _basic_push(self, overwrite=False, stop_revision=None):
601
result = branch.BranchPushResult()
821
result = GitBranchPushResult()
602
822
result.source_branch = self.source
603
823
result.target_branch = self.target
604
824
result.old_revid = self.target.last_revision()
605
825
refs, stop_revision = self.update_refs(stop_revision)
606
826
self.target.generate_revision_history(stop_revision, result.old_revid)
607
self.update_tags(refs)
827
result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
828
source_refs=refs, overwrite=overwrite)
608
829
result.new_revid = self.target.last_revision()
609
830
return result
610
831
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
832
def update_refs(self, stop_revision=None):
617
interrepo = repository.InterRepository.get(self.source.repository,
833
interrepo = _mod_repository.InterRepository.get(self.source.repository,
618
834
self.target.repository)
619
835
if stop_revision is None:
620
836
refs = interrepo.fetch(branches=["HEAD"])
631
847
result = GitPullResult()
632
848
result.source_branch = self.source
633
849
result.target_branch = self.target
634
result.old_revid = self.target.last_revision()
635
refs, stop_revision = self.update_refs(stop_revision)
636
self.target.generate_revision_history(stop_revision, result.old_revid)
637
self.update_tags(refs)
638
result.new_revid = self.target.last_revision()
850
self.source.lock_read()
851
try:
852
self.target.lock_write()
853
try:
854
result.old_revid = self.target.last_revision()
855
refs, stop_revision = self.update_refs(stop_revision)
856
self.target.generate_revision_history(stop_revision, result.old_revid)
857
result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
858
overwrite=overwrite, source_refs=refs)
859
result.new_revid = self.target.last_revision()
860
result.local_branch = None
861
result.master_branch = result.target_branch
862
if run_hooks:
863
for hook in branch.Branch.hooks['post_pull']:
864
hook(result)
865
finally:
866
self.target.unlock()
867
finally:
868
self.source.unlock()
639
869
return result
640
870
641
871
642
872
class InterToGitBranch(branch.GenericInterBranch):
643
"""InterBranch implementation that pulls from Git into bzr."""
873
"""InterBranch implementation that pulls into a Git branch."""
644
874
645
875
def __init__(self, source, target):
646
876
super(InterToGitBranch, self).__init__(source, target)
647
self.interrepo = repository.InterRepository.get(source.repository,
877
self.interrepo = _mod_repository.InterRepository.get(source.repository,
648
878
target.repository)
649
879
650
880
@staticmethod
651
881
def _get_branch_formats_to_test():
652
return []
882
try:
883
default_format = branch.format_registry.get_default()
884
except AttributeError:
885
default_format = branch.BranchFormat._default_format
886
return [(default_format, GitBranchFormat())]
653
887
654
888
@classmethod
655
889
def is_compatible(self, source, target):
656
890
return (not isinstance(source, GitBranch) and
657
891
isinstance(target, GitBranch))
658
892
659
def update_revisions(self, *args, **kwargs):
660
raise NoPushSupport()
661
662
def _get_new_refs(self, stop_revision=None):
893
def _get_new_refs(self, stop_revision=None, fetch_tags=None):
663
894
if stop_revision is None:
664
stop_revision = self.source.last_revision()
895
(stop_revno, stop_revision) = self.source.last_revision_info()
896
else:
897
stop_revno = self.source.revision_id_to_revno(stop_revision)
665
898
assert type(stop_revision) is str
666
899
main_ref = self.target.ref or "refs/heads/master"
667
900
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
901
if fetch_tags is None:
902
c = self.source.get_config()
903
fetch_tags = c.get_user_option_as_bool('branch.fetch_tags')
904
if fetch_tags:
905
for name, revid in self.source.tags.get_tag_dict().iteritems():
906
if self.source.repository.has_revision(revid):
907
refs[tag_name_to_ref(name)] = (None, revid)
908
return refs, main_ref, (stop_revno, stop_revision)
672
909
673
910
def pull(self, overwrite=False, stop_revision=None, local=False,
674
possible_transports=None):
675
from dulwich.protocol import ZERO_SHA
911
possible_transports=None, run_hooks=True):
676
912
result = GitBranchPullResult()
677
913
result.source_branch = self.source
678
914
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]
915
self.source.lock_read()
916
try:
917
self.target.lock_write()
918
try:
919
new_refs, main_ref, stop_revinfo = self._get_new_refs(stop_revision)
920
def update_refs(old_refs):
921
mutter("updating refs. old refs: %r, new refs: %r",
922
old_refs, new_refs)
923
# FIXME: Check for diverged branches
924
return new_refs
925
try:
926
result.revidmap, old_refs, new_refs = self.interrepo.fetch_refs(
927
update_refs, lossy=False)
928
except NoPushSupport:
929
raise errors.NoRoundtrippingSupport(self.source, self.target)
930
(result.old_revid, old_sha1) = old_refs.get(main_ref, (ZERO_SHA, NULL_REVISION))
931
if result.old_revid is None:
932
result.old_revid = self.target.lookup_foreign_revision_id(old_sha1)
933
result.new_revid = new_refs[main_ref][1]
934
result.local_branch = None
935
result.master_branch = self.target
936
if run_hooks:
937
for hook in branch.Branch.hooks['post_pull']:
938
hook(result)
939
finally:
940
self.target.unlock()
941
finally:
942
self.source.unlock()
689
943
return result
690
944
691
def push(self, overwrite=False, stop_revision=None,
945
def push(self, overwrite=False, stop_revision=None, lossy=False,
692
946
_override_hook_source_branch=None):
693
from dulwich.protocol import ZERO_SHA
694
947
result = GitBranchPushResult()
695
948
result.source_branch = self.source
696
949
result.target_branch = self.target
697
new_refs, main_ref = self._get_new_refs(stop_revision)
950
result.local_branch = None
951
result.master_branch = result.target_branch
952
new_refs, main_ref, stop_revinfo = self._get_new_refs(stop_revision)
698
953
def update_refs(old_refs):
699
refs = dict(old_refs)
954
mutter("updating refs. old refs: %r, new refs: %r",
955
old_refs, new_refs)
700
956
# 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))
957
return new_refs
958
try:
959
result.revidmap, old_refs, new_refs = self.interrepo.fetch_refs(
960
update_refs, lossy=lossy)
961
except NoPushSupport:
962
raise errors.NoRoundtrippingSupport(self.source, self.target)
963
(old_sha1, result.old_revid) = old_refs.get(main_ref, (ZERO_SHA, NULL_REVISION))
705
964
if result.old_revid is None:
706
965
result.old_revid = self.target.lookup_foreign_revision_id(old_sha1)
707
result.new_revid = new_refs[main_ref]
966
result.new_revid = new_refs[main_ref][1]
967
(result.new_original_revno, result.new_original_revid) = stop_revinfo
968
for hook in branch.Branch.hooks['post_push']:
969
hook(result)
708
970
return result
709
971
710
972
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
branch.InterBranch.register_optimiser(InterGitRemoteLocalBranch)
973
# For compatibility with bzr < 2.4
974
return self.push(lossy=True, stop_revision=stop_revision)
975
976
977
branch.InterBranch.register_optimiser(InterGitLocalGitBranch)
728
978
branch.InterBranch.register_optimiser(InterFromGitBranch)
729
979
branch.InterBranch.register_optimiser(InterToGitBranch)
730
branch.InterBranch.register_optimiser(InterGitLocalRemoteBranch)
980
branch.InterBranch.register_optimiser(InterLocalGitRemoteGitBranch)
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0