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.1517
- compare with another revision
- download diff
- download tarball
- view history from revision 0.200.1517
- Committer: Jelmer Vernooij
- Date: 2011-12-16 22:02:41 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-20111216220241-l18aluz82ofl2tc0
Add test for option command in git-remote-helper.
- files added:
- .testr.conf
- po
- files removed:
- inventory.py
- files modified:
- .bzrignore
added
removed
branch.py
1
# Copyright (C) 2007 Canonical Ltd
2
# Copyright (C) 2009-2010 Jelmer Vernooij <jelmer@samba.org>
1
# Copyright (C) 2007,2011 Canonical Ltd
2
# Copyright (C) 2009-2011 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
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
Commit,
22
Tag,
23
ZERO_SHA,
23
24
)
25
from dulwich.repo import check_ref_format
24
26
25
27
from bzrlib import (
26
28
branch,
27
29
bzrdir,
28
30
config,
29
31
errors,
30
repository,
32
repository as _mod_repository,
31
33
revision,
32
34
tag,
33
35
transport,
36
urlutils,
34
37
)
35
38
from bzrlib.decorators import (
36
39
needs_read_lock,
41
44
from bzrlib.trace import (
42
45
is_quiet,
43
46
mutter,
47
warning,
44
48
)
45
49
46
50
from bzrlib.plugins.git.config import (
47
51
GitBranchConfig,
52
GitBranchStack,
48
53
)
49
54
from bzrlib.plugins.git.errors import (
50
55
NoPushSupport,
51
56
NoSuchRef,
52
57
)
53
58
from bzrlib.plugins.git.refs import (
59
is_tag,
54
60
ref_to_branch_name,
55
extract_tags,
61
ref_to_tag_name,
56
62
tag_name_to_ref,
57
63
)
64
from bzrlib.plugins.git.unpeel_map import (
65
UnpeelMap,
66
)
58
67
59
68
from bzrlib.foreign import ForeignBranch
60
69
65
74
def _lookup_revno(self, revid):
66
75
assert isinstance(revid, str), "was %r" % revid
67
76
# Try in source branch first, it'll be faster
68
return self.target_branch.revision_id_to_revno(revid)
77
self.target_branch.lock_read()
78
try:
79
return self.target_branch.revision_id_to_revno(revid)
80
finally:
81
self.target_branch.unlock()
69
82
70
83
@property
71
84
def old_revno(self):
76
89
return self._lookup_revno(self.new_revid)
77
90
78
91
79
class LocalGitTagDict(tag.BasicTags):
80
"""Dictionary with tags in a local repository."""
92
class GitTags(tag.BasicTags):
93
"""Ref-based tag dictionary."""
81
94
82
95
def __init__(self, branch):
83
96
self.branch = branch
84
97
self.repository = branch.repository
85
98
99
def get_refs_container(self):
100
raise NotImplementedError(self.get_refs_container)
101
102
def _iter_tag_refs(self, refs):
103
"""Iterate over the tag refs.
104
105
:param refs: Refs dictionary (name -> git sha1)
106
:return: iterator over (name, peeled_sha1, unpeeled_sha1, bzr_revid)
107
"""
108
for k, unpeeled in refs.as_dict().iteritems():
109
try:
110
tag_name = ref_to_tag_name(k)
111
except (ValueError, UnicodeDecodeError):
112
continue
113
peeled = refs.get_peeled(k)
114
if peeled is None:
115
peeled = self.repository.bzrdir._git.object_store.peel_sha(unpeeled).id
116
yield (tag_name, peeled, unpeeled,
117
self.branch.lookup_foreign_revision_id(peeled))
118
119
def _merge_to_remote_git(self, target_repo, new_refs, overwrite=False):
120
updates = {}
121
conflicts = []
122
def get_changed_refs(old_refs):
123
ret = dict(old_refs)
124
for k, v in new_refs.iteritems():
125
if not is_tag(k):
126
continue
127
name = ref_to_tag_name(k)
128
if old_refs.get(k) == v:
129
pass
130
elif overwrite or not k in old_refs:
131
ret[k] = v
132
updates[name] = target_repo.lookup_foreign_revision_id(v)
133
else:
134
conflicts.append((name, v, old_refs[k]))
135
return ret
136
target_repo.bzrdir.send_pack(get_changed_refs, lambda have, want: [])
137
return updates, conflicts
138
139
def _merge_to_local_git(self, target_repo, refs, overwrite=False):
140
conflicts = []
141
updates = {}
142
for k, unpeeled in refs.as_dict().iteritems():
143
if not is_tag(k):
144
continue
145
name = ref_to_tag_name(k)
146
peeled = self.repository.bzrdir.get_peeled(k)
147
if target_repo._git.refs.get(k) == unpeeled:
148
pass
149
elif overwrite or not k in target_repo._git.refs:
150
target_repo._git.refs[k] = unpeeled or peeled
151
updates[name] = target_repo.lookup_foreign_revision_id(peeled)
152
else:
153
conflicts.append((name, peeled, target_repo._git.refs[k]))
154
return updates, conflicts
155
156
def _merge_to_git(self, to_tags, refs, overwrite=False):
157
target_repo = to_tags.repository
158
if self.repository.has_same_location(target_repo):
159
return {}, []
160
if getattr(target_repo, "_git", None):
161
return self._merge_to_local_git(target_repo, refs, overwrite)
162
else:
163
return self._merge_to_remote_git(target_repo, refs, overwrite)
164
165
def _merge_to_non_git(self, to_tags, refs, overwrite=False):
166
unpeeled_map = defaultdict(set)
167
conflicts = []
168
updates = {}
169
result = dict(to_tags.get_tag_dict())
170
for n, peeled, unpeeled, bzr_revid in self._iter_tag_refs(refs):
171
if unpeeled is not None:
172
unpeeled_map[peeled].add(unpeeled)
173
if result.get(n) == bzr_revid:
174
pass
175
elif n not in result or overwrite:
176
result[n] = bzr_revid
177
updates[n] = bzr_revid
178
else:
179
conflicts.append((n, result[n], bzr_revid))
180
to_tags._set_tag_dict(result)
181
if len(unpeeled_map) > 0:
182
map_file = UnpeelMap.from_repository(to_tags.branch.repository)
183
map_file.update(unpeeled_map)
184
map_file.save_in_repository(to_tags.branch.repository)
185
return updates, conflicts
186
187
def merge_to(self, to_tags, overwrite=False, ignore_master=False,
188
source_refs=None):
189
"""See Tags.merge_to."""
190
if source_refs is None:
191
source_refs = self.get_refs_container()
192
if self == to_tags:
193
return {}, []
194
if isinstance(to_tags, GitTags):
195
return self._merge_to_git(to_tags, source_refs,
196
overwrite=overwrite)
197
else:
198
if ignore_master:
199
master = None
200
else:
201
master = to_tags.branch.get_master_branch()
202
updates, conflicts = self._merge_to_non_git(to_tags, source_refs,
203
overwrite=overwrite)
204
if master is not None:
205
extra_updates, extra_conflicts = self.merge_to(
206
master.tags, overwrite=overwrite,
207
source_refs=source_refs,
208
ignore_master=ignore_master)
209
updates.update(extra_updates)
210
conflicts += extra_conflicts
211
return updates, conflicts
212
86
213
def get_tag_dict(self):
87
214
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
94
while isinstance(obj, Tag):
95
v = obj.object[1]
96
obj = self.repository._git[v]
97
if not isinstance(obj, Commit):
98
mutter("Tag %s points at object %r that is not a commit, "
99
"ignoring", k, obj)
100
continue
101
ret[k] = self.branch.lookup_foreign_revision_id(v)
215
refs = self.get_refs_container()
216
for (name, peeled, unpeeled, bzr_revid) in self._iter_tag_refs(refs):
217
ret[name] = bzr_revid
102
218
return ret
103
219
220
221
class LocalGitTagDict(GitTags):
222
"""Dictionary with tags in a local repository."""
223
224
def __init__(self, branch):
225
super(LocalGitTagDict, self).__init__(branch)
226
self.refs = self.repository.bzrdir._git.refs
227
228
def get_refs_container(self):
229
return self.refs
230
104
231
def _set_tag_dict(self, to_dict):
105
extra = set(self.repository._git.get_refs().keys())
232
extra = set(self.refs.allkeys())
106
233
for k, revid in to_dict.iteritems():
107
234
name = tag_name_to_ref(k)
108
235
if name in extra:
109
236
extra.remove(name)
110
237
self.set_tag(k, revid)
111
238
for name in extra:
112
if name.startswith("refs/tags/"):
239
if is_tag(name):
113
240
del self.repository._git[name]
114
241
115
242
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):
243
try:
244
git_sha, mapping = self.branch.lookup_bzr_revision_id(revid)
245
except errors.NoSuchRevision:
246
raise errors.GhostTagsNotSupported(self)
247
self.refs[tag_name_to_ref(name)] = git_sha
248
249
250
class DictTagDict(tag.BasicTags):
121
251
122
252
def __init__(self, branch, tags):
123
253
super(DictTagDict, self).__init__(branch)
127
257
return self._tags
128
258
129
259
260
class GitSymrefBranchFormat(branch.BranchFormat):
261
262
def get_format_description(self):
263
return 'Git Symbolic Reference Branch'
264
265
def network_name(self):
266
return "git"
267
268
def get_reference(self, controldir, name=None):
269
return controldir.get_branch_reference(name)
270
271
def set_reference(self, controldir, name, target):
272
return controldir.set_branch_reference(name, target)
273
274
130
275
class GitBranchFormat(branch.BranchFormat):
131
276
132
277
def get_format_description(self):
138
283
def supports_tags(self):
139
284
return True
140
285
286
def supports_leaving_lock(self):
287
return False
288
289
def supports_tags_referencing_ghosts(self):
290
return False
291
292
def tags_are_versioned(self):
293
return False
294
295
@property
296
def _matchingbzrdir(self):
297
from bzrlib.plugins.git.dir import LocalGitControlDirFormat
298
return LocalGitControlDirFormat()
299
141
300
def get_foreign_tests_branch_factory(self):
142
301
from bzrlib.plugins.git.tests.test_branch import ForeignTestsBranchFactory
143
302
return ForeignTestsBranchFactory()
144
303
145
304
def make_tags(self, branch):
146
if getattr(branch.repository, "get_refs", None) is not None:
305
try:
306
return branch.tags
307
except AttributeError:
308
pass
309
if getattr(branch.repository, "_git", None) is None:
147
310
from bzrlib.plugins.git.remote import RemoteGitTagDict
148
311
return RemoteGitTagDict(branch)
149
312
else:
150
313
return LocalGitTagDict(branch)
151
314
315
def initialize(self, a_bzrdir, name=None, repository=None,
316
append_revisions_only=None):
317
from bzrlib.plugins.git.dir import LocalGitDir
318
if not isinstance(a_bzrdir, LocalGitDir):
319
raise errors.IncompatibleFormat(self, a_bzrdir._format)
320
return a_bzrdir.create_branch(repository=repository, name=name,
321
append_revisions_only=append_revisions_only)
322
152
323
153
324
class GitReadLock(object):
154
325
159
330
class GitWriteLock(object):
160
331
161
332
def __init__(self, unlock):
333
self.branch_token = None
162
334
self.unlock = unlock
163
335
164
336
165
337
class GitBranch(ForeignBranch):
166
338
"""An adapter to git repositories for bzr Branch objects."""
167
339
168
def __init__(self, bzrdir, repository, ref, lockfiles, tagsdict=None):
340
@property
341
def control_transport(self):
342
return self.bzrdir.control_transport
343
344
def __init__(self, bzrdir, repository, ref):
345
self.base = bzrdir.root_transport.base
169
346
self.repository = repository
170
347
self._format = GitBranchFormat()
171
self.control_files = lockfiles
172
348
self.bzrdir = bzrdir
349
self._lock_mode = None
350
self._lock_count = 0
173
351
super(GitBranch, self).__init__(repository.get_mapping())
174
if tagsdict is not None:
175
self.tags = DictTagDict(self, tagsdict)
176
352
self.ref = ref
177
self.name = ref_to_branch_name(ref)
353
try:
354
self.name = ref_to_branch_name(ref)
355
except ValueError:
356
self.name = None
178
357
self._head = None
179
self.base = bzrdir.root_transport.base
180
358
181
def _get_checkout_format(self):
359
def _get_checkout_format(self, lightweight=False):
182
360
"""Return the most suitable metadir for a checkout of this branch.
183
361
Weaves are used if this branch's repository uses weaves.
184
362
"""
191
369
return ret
192
370
return "git"
193
371
372
def get_config(self):
373
return GitBranchConfig(self)
374
375
def get_config_stack(self):
376
return GitBranchStack(self)
377
194
378
def _get_nick(self, local=False, possible_master_transports=None):
195
379
"""Find the nick name for this branch.
196
380
205
389
206
390
def __repr__(self):
207
391
return "<%s(%r, %r)>" % (self.__class__.__name__, self.repository.base,
208
self.ref or "HEAD")
392
self.name)
209
393
210
394
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)
395
if revid == NULL_REVISION:
396
newhead = ZERO_SHA
397
else:
398
# FIXME: Check that old_revid is in the ancestry of revid
399
newhead, self.mapping = self.repository.lookup_bzr_revision_id(revid)
400
if self.mapping is None:
401
raise AssertionError
213
402
self._set_head(newhead)
214
403
215
def lock_write(self):
216
self.control_files.lock_write()
404
def lock_write(self, token=None):
405
if token is not None:
406
raise errors.TokenLockingNotSupported(self)
407
if self._lock_mode:
408
if self._lock_mode == 'r':
409
raise errors.ReadOnlyError(self)
410
self._lock_count += 1
411
else:
412
self._lock_mode = 'w'
413
self._lock_count = 1
414
self.repository.lock_write()
217
415
return GitWriteLock(self.unlock)
218
416
417
def leave_lock_in_place(self):
418
raise NotImplementedError(self.leave_lock_in_place)
419
420
def dont_leave_lock_in_place(self):
421
raise NotImplementedError(self.dont_leave_lock_in_place)
422
219
423
def get_stacked_on_url(self):
220
424
# Git doesn't do stacking (yet...)
221
425
raise errors.UnstackableBranchFormat(self._format, self.base)
229
433
# FIXME: Set "origin" url in .git/config ?
230
434
pass
231
435
436
def break_lock(self):
437
raise NotImplementedError(self.break_lock)
438
232
439
def lock_read(self):
233
self.control_files.lock_read()
440
if self._lock_mode:
441
assert self._lock_mode in ('r', 'w')
442
self._lock_count += 1
443
else:
444
self._lock_mode = 'r'
445
self._lock_count = 1
446
self.repository.lock_read()
234
447
return GitReadLock(self.unlock)
235
448
449
def peek_lock_mode(self):
450
return self._lock_mode
451
236
452
def is_locked(self):
237
return self.control_files.is_locked()
453
return (self._lock_mode is not None)
238
454
239
455
def unlock(self):
240
self.control_files.unlock()
456
"""See Branch.unlock()."""
457
self._lock_count -= 1
458
if self._lock_count == 0:
459
self._lock_mode = None
460
self._clear_cached_state()
461
self.repository.unlock()
241
462
242
463
def get_physical_lock_status(self):
243
464
return False
265
486
class LocalGitBranch(GitBranch):
266
487
"""A local Git branch."""
267
488
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()):
489
def __init__(self, bzrdir, repository, ref):
490
super(LocalGitBranch, self).__init__(bzrdir, repository, ref)
491
refs = bzrdir.get_refs_container()
492
if not (ref in refs or "HEAD" in refs):
273
493
raise errors.NotBranchError(self.base)
274
494
275
495
def create_checkout(self, to_location, revision_id=None, lightweight=False,
277
497
if lightweight:
278
498
t = transport.get_transport(to_location)
279
499
t.ensure_base()
280
format = self._get_checkout_format()
500
format = self._get_checkout_format(lightweight=True)
281
501
checkout = format.initialize_on_transport(t)
282
502
from_branch = branch.BranchReferenceFormat().initialize(checkout,
283
503
self)
298
518
:return: WorkingTree object of checkout.
299
519
"""
300
520
checkout_branch = bzrdir.BzrDir.create_branch_convenience(
301
to_location, force_new_tree=False)
521
to_location, force_new_tree=False,
522
format=self._get_checkout_format(lightweight=False))
302
523
checkout = checkout_branch.bzrdir
303
524
checkout_branch.bind(self)
304
525
# pull up to the specified revision_id to set the initial
306
527
checkout_branch.pull(self, stop_revision=revision_id)
307
528
return checkout.create_workingtree(revision_id, hardlink=hardlink)
308
529
530
def fetch(self, from_branch, last_revision=None, limit=None):
531
return branch.InterBranch.get(from_branch, self).fetch(
532
stop_revision=last_revision, limit=limit)
533
309
534
def _gen_revision_history(self):
310
535
if self.head is None:
311
536
return []
312
ret = list(self.repository.iter_reverse_revision_history(
313
self.last_revision()))
537
graph = self.repository.get_graph()
538
ret = list(graph.iter_lefthand_ancestry(self.last_revision(),
539
(revision.NULL_REVISION, )))
314
540
ret.reverse()
315
541
return ret
316
542
320
546
except KeyError:
321
547
return None
322
548
323
def set_last_revision_info(self, revno, revid):
324
self.set_last_revision(revid)
549
def _read_last_revision_info(self):
550
last_revid = self.last_revision()
551
graph = self.repository.get_graph()
552
revno = graph.find_distance_to_null(last_revid,
553
[(revision.NULL_REVISION, 0)])
554
return revno, last_revid
555
556
def set_last_revision_info(self, revno, revision_id):
557
self.set_last_revision(revision_id)
558
self._last_revision_info_cache = revno, revision_id
325
559
326
560
def set_last_revision(self, revid):
327
(newhead, self.mapping) = self.repository.lookup_bzr_revision_id(revid)
328
self.head = newhead
561
if not revid or not isinstance(revid, basestring):
562
raise errors.InvalidRevisionId(revision_id=revid, branch=self)
563
if revid == NULL_REVISION:
564
newhead = ZERO_SHA
565
else:
566
(newhead, self.mapping) = self.repository.lookup_bzr_revision_id(revid)
567
if self.mapping is None:
568
raise AssertionError
569
self._set_head(newhead)
329
570
330
571
def _set_head(self, value):
331
572
self._head = value
334
575
335
576
head = property(_get_head, _set_head)
336
577
337
def get_config(self):
338
return GitBranchConfig(self)
339
340
578
def get_push_location(self):
341
579
"""See Branch.get_push_location."""
342
580
push_loc = self.get_config().get_user_option('push_location')
351
589
return True
352
590
353
591
592
def _quick_lookup_revno(local_branch, remote_branch, revid):
593
assert isinstance(revid, str), "was %r" % revid
594
# Try in source branch first, it'll be faster
595
local_branch.lock_read()
596
try:
597
try:
598
return local_branch.revision_id_to_revno(revid)
599
except errors.NoSuchRevision:
600
graph = local_branch.repository.get_graph()
601
try:
602
return graph.find_distance_to_null(revid,
603
[(revision.NULL_REVISION, 0)])
604
except errors.GhostRevisionsHaveNoRevno:
605
# FIXME: Check using graph.find_distance_to_null() ?
606
remote_branch.lock_read()
607
try:
608
return remote_branch.revision_id_to_revno(revid)
609
finally:
610
remote_branch.unlock()
611
finally:
612
local_branch.unlock()
613
614
354
615
class GitBranchPullResult(branch.PullResult):
355
616
356
617
def __init__(self):
371
632
self._show_tag_conficts(to_file)
372
633
373
634
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)
635
return _quick_lookup_revno(self.target_branch, self.source_branch,
636
revid)
381
637
382
638
def _get_old_revno(self):
383
639
if self._old_revno is not None:
403
659
class GitBranchPushResult(branch.BranchPushResult):
404
660
405
661
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)
662
return _quick_lookup_revno(self.source_branch, self.target_branch,
663
revid)
413
664
414
665
@property
415
666
def old_revno(self):
417
668
418
669
@property
419
670
def new_revno(self):
671
new_original_revno = getattr(self, "new_original_revno", None)
672
if new_original_revno:
673
return new_original_revno
674
if getattr(self, "new_original_revid", None) is not None:
675
return self._lookup_revno(self.new_original_revid)
420
676
return self._lookup_revno(self.new_revid)
421
677
422
678
425
681
426
682
@staticmethod
427
683
def _get_branch_formats_to_test():
428
return []
684
try:
685
default_format = branch.format_registry.get_default()
686
except AttributeError:
687
default_format = branch.BranchFormat._default_format
688
return [
689
(GitBranchFormat(), GitBranchFormat()),
690
(GitBranchFormat(), default_format)]
429
691
430
692
@classmethod
431
693
def _get_interrepo(self, source, target):
432
return repository.InterRepository.get(source.repository,
433
target.repository)
694
return _mod_repository.InterRepository.get(source.repository, target.repository)
434
695
435
696
@classmethod
436
697
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
"""
698
if not isinstance(source, GitBranch):
699
return False
700
if isinstance(target, GitBranch):
701
# InterLocalGitRemoteGitBranch or InterToGitBranch should be used
702
return False
703
if getattr(cls._get_interrepo(source, target), "fetch_objects", None) is None:
704
# fetch_objects is necessary for this to work
705
return False
706
return True
707
708
def fetch(self, stop_revision=None, fetch_tags=None, limit=None):
709
self.fetch_objects(stop_revision, fetch_tags=fetch_tags, limit=limit)
710
711
def fetch_objects(self, stop_revision, fetch_tags, limit=None):
449
712
interrepo = self._get_interrepo(self.source, self.target)
713
if fetch_tags is None:
714
c = self.source.get_config()
715
fetch_tags = c.get_user_option_as_bool('branch.fetch_tags')
450
716
def determine_wants(heads):
451
717
if self.source.ref is not None and not self.source.ref in heads:
452
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:
718
raise NoSuchRef(self.source.ref, self.source.user_url, heads.keys())
719
720
if stop_revision is None:
458
721
if self.source.ref is not None:
459
722
head = heads[self.source.ref]
460
723
else:
461
724
head = heads["HEAD"]
462
725
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]
726
else:
727
self._last_revid = stop_revision
728
real = interrepo.get_determine_wants_revids(
729
[self._last_revid], include_tags=fetch_tags)
730
return real(heads)
466
731
pack_hint, head, refs = interrepo.fetch_objects(
467
732
determine_wants, self.source.mapping, limit=limit)
468
733
if (pack_hint is not None and
469
734
self.target.repository._format.pack_compresses):
470
735
self.target.repository.pack(hint=pack_hint)
471
if head is not None:
472
self._last_revid = self.source.lookup_foreign_revision_id(head)
736
return head, refs
737
738
def _update_revisions(self, stop_revision=None, overwrite=False):
739
head, refs = self.fetch_objects(stop_revision, fetch_tags=None)
473
740
if overwrite:
474
741
prev_last_revid = None
475
742
else:
476
743
prev_last_revid = self.target.last_revision()
477
744
self.target.generate_revision_history(self._last_revid,
478
prev_last_revid)
479
return head
745
prev_last_revid, self.source)
746
return head, refs
480
747
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)
748
def _basic_pull(self, stop_revision, overwrite, run_hooks,
749
_override_hook_target, _hook_master):
750
result = GitBranchPullResult()
751
result.source_branch = self.source
752
if _override_hook_target is None:
753
result.target_branch = self.target
754
else:
755
result.target_branch = _override_hook_target
756
self.source.lock_read()
757
try:
758
self.target.lock_write()
759
try:
760
# We assume that during 'pull' the target repository is closer than
761
# the source one.
762
(result.old_revno, result.old_revid) = \
763
self.target.last_revision_info()
764
result.new_git_head, remote_refs = self._update_revisions(
765
stop_revision, overwrite=overwrite)
766
tags_ret = self.source.tags.merge_to(
767
self.target.tags, overwrite)
768
if isinstance(tags_ret, tuple):
769
result.tag_updates, result.tag_conflicts = tags_ret
770
else:
771
result.tag_conflicts = tags_ret
772
(result.new_revno, result.new_revid) = \
773
self.target.last_revision_info()
774
if _hook_master:
775
result.master_branch = _hook_master
776
result.local_branch = result.target_branch
777
else:
778
result.master_branch = result.target_branch
779
result.local_branch = None
780
if run_hooks:
781
for hook in branch.Branch.hooks['post_pull']:
782
hook(result)
783
return result
784
finally:
785
self.target.unlock()
786
finally:
787
self.source.unlock()
485
788
486
789
def pull(self, overwrite=False, stop_revision=None,
487
790
possible_transports=None, _hook_master=None, run_hooks=True,
488
_override_hook_target=None, local=False, limit=None):
791
_override_hook_target=None, local=False):
489
792
"""See Branch.pull.
490
793
491
794
:param _hook_master: Private parameter - set the branch to
495
798
so it should not run its hooks.
496
799
:param _override_hook_target: Private parameter - set the branch to be
497
800
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
801
"""
501
802
# This type of branch can't be bound.
502
if local:
803
bound_location = self.target.get_bound_location()
804
if local and not bound_location:
503
805
raise errors.LocalRequiresBoundBranch()
504
result = GitBranchPullResult()
505
result.source_branch = self.source
506
if _override_hook_target is None:
507
result.target_branch = self.target
508
else:
509
result.target_branch = _override_hook_target
806
master_branch = None
807
source_is_master = False
510
808
self.source.lock_read()
809
if bound_location:
810
# bound_location comes from a config file, some care has to be
811
# taken to relate it to source.user_url
812
normalized = urlutils.normalize_url(bound_location)
813
try:
814
relpath = self.source.user_transport.relpath(normalized)
815
source_is_master = (relpath == '')
816
except (errors.PathNotChild, errors.InvalidURL):
817
source_is_master = False
818
if not local and bound_location and not source_is_master:
819
# not pulling from master, so we need to update master.
820
master_branch = self.target.get_master_branch(possible_transports)
821
master_branch.lock_write()
511
822
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)
823
try:
824
if master_branch:
825
# pull from source into master.
826
master_branch.pull(self.source, overwrite, stop_revision,
827
run_hooks=False)
828
result = self._basic_pull(stop_revision, overwrite, run_hooks,
829
_override_hook_target, _hook_master=master_branch)
830
finally:
831
self.source.unlock()
532
832
finally:
533
self.source.unlock()
833
if master_branch:
834
master_branch.unlock()
534
835
return result
535
836
536
837
def _basic_push(self, overwrite=False, stop_revision=None):
537
838
result = branch.BranchPushResult()
538
839
result.source_branch = self.source
539
840
result.target_branch = self.target
540
graph = self.target.repository.get_graph(self.source.repository)
541
841
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,
842
result.new_git_head, remote_refs = self._update_revisions(
843
stop_revision, overwrite=overwrite)
844
tags_ret = self.source.tags.merge_to(self.target.tags,
545
845
overwrite)
846
if isinstance(tags_ret, tuple):
847
(result.tag_updates, result.tag_conflicts) = tags_ret
848
else:
849
result.tag_conflicts = tags_ret
546
850
result.new_revno, result.new_revid = self.target.last_revision_info()
547
851
return result
548
852
550
854
class InterGitBranch(branch.GenericInterBranch):
551
855
"""InterBranch implementation that pulls between Git branches."""
552
856
553
554
class InterGitLocalRemoteBranch(InterGitBranch):
857
def fetch(self, stop_revision=None, fetch_tags=None, limit=None):
858
raise NotImplementedError(self.fetch)
859
860
861
class InterLocalGitRemoteGitBranch(InterGitBranch):
555
862
"""InterBranch that copies from a local to a remote git branch."""
556
863
557
864
@staticmethod
558
865
def _get_branch_formats_to_test():
866
# FIXME
559
867
return []
560
868
561
869
@classmethod
565
873
isinstance(target, RemoteGitBranch))
566
874
567
875
def _basic_push(self, overwrite=False, stop_revision=None):
568
from dulwich.protocol import ZERO_SHA
569
876
result = GitBranchPushResult()
570
877
result.source_branch = self.source
571
878
result.target_branch = self.target
573
880
stop_revision = self.source.last_revision()
574
881
# FIXME: Check for diverged branches
575
882
def get_changed_refs(old_refs):
576
result.old_revid = self.target.lookup_foreign_revision_id(old_refs.get(self.target.ref, ZERO_SHA))
883
old_ref = old_refs.get(self.target.ref, ZERO_SHA)
884
result.old_revid = self.target.lookup_foreign_revision_id(old_ref)
577
885
refs = { self.target.ref: self.source.repository.lookup_bzr_revision_id(stop_revision)[0] }
578
886
result.new_revid = stop_revision
579
887
for name, sha in self.source.repository._git.refs.as_dict("refs/tags").iteritems():
584
892
return result
585
893
586
894
587
class InterGitRemoteLocalBranch(InterGitBranch):
895
class InterGitLocalGitBranch(InterGitBranch):
588
896
"""InterBranch that copies from a remote to a local git branch."""
589
897
590
898
@staticmethod
591
899
def _get_branch_formats_to_test():
900
# FIXME
592
901
return []
593
902
594
903
@classmethod
595
904
def is_compatible(self, source, target):
596
from bzrlib.plugins.git.remote import RemoteGitBranch
597
return (isinstance(source, RemoteGitBranch) and
905
return (isinstance(source, GitBranch) and
598
906
isinstance(target, LocalGitBranch))
599
907
600
908
def _basic_push(self, overwrite=False, stop_revision=None):
601
result = branch.BranchPushResult()
909
result = GitBranchPushResult()
602
910
result.source_branch = self.source
603
911
result.target_branch = self.target
604
912
result.old_revid = self.target.last_revision()
605
913
refs, stop_revision = self.update_refs(stop_revision)
606
914
self.target.generate_revision_history(stop_revision, result.old_revid)
607
self.update_tags(refs)
915
tags_ret = self.source.tags.merge_to(self.target.tags,
916
source_refs=refs, overwrite=overwrite)
917
if isinstance(tags_ret, tuple):
918
(result.tag_updates, result.tag_conflicts) = tags_ret
919
else:
920
result.tag_conflicts = tags_ret
608
921
result.new_revid = self.target.last_revision()
609
922
return result
610
923
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
924
def update_refs(self, stop_revision=None):
617
interrepo = repository.InterRepository.get(self.source.repository,
925
interrepo = _mod_repository.InterRepository.get(self.source.repository,
618
926
self.target.repository)
619
927
if stop_revision is None:
620
928
refs = interrepo.fetch(branches=["HEAD"])
631
939
result = GitPullResult()
632
940
result.source_branch = self.source
633
941
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()
942
self.source.lock_read()
943
try:
944
self.target.lock_write()
945
try:
946
result.old_revid = self.target.last_revision()
947
refs, stop_revision = self.update_refs(stop_revision)
948
self.target.generate_revision_history(stop_revision, result.old_revid)
949
tags_ret = self.source.tags.merge_to(self.target.tags,
950
overwrite=overwrite, source_refs=refs)
951
if isinstance(tags_ret, tuple):
952
(result.tag_updates, result.tag_conflicts) = tags_ret
953
else:
954
result.tag_conflicts = tags_ret
955
result.new_revid = self.target.last_revision()
956
result.local_branch = None
957
result.master_branch = result.target_branch
958
if run_hooks:
959
for hook in branch.Branch.hooks['post_pull']:
960
hook(result)
961
finally:
962
self.target.unlock()
963
finally:
964
self.source.unlock()
639
965
return result
640
966
641
967
642
968
class InterToGitBranch(branch.GenericInterBranch):
643
"""InterBranch implementation that pulls from Git into bzr."""
969
"""InterBranch implementation that pulls into a Git branch."""
644
970
645
971
def __init__(self, source, target):
646
972
super(InterToGitBranch, self).__init__(source, target)
647
self.interrepo = repository.InterRepository.get(source.repository,
973
self.interrepo = _mod_repository.InterRepository.get(source.repository,
648
974
target.repository)
649
975
650
976
@staticmethod
651
977
def _get_branch_formats_to_test():
652
return []
978
try:
979
default_format = branch.format_registry.get_default()
980
except AttributeError:
981
default_format = branch.BranchFormat._default_format
982
return [(default_format, GitBranchFormat())]
653
983
654
984
@classmethod
655
985
def is_compatible(self, source, target):
656
986
return (not isinstance(source, GitBranch) and
657
987
isinstance(target, GitBranch))
658
988
659
def update_revisions(self, *args, **kwargs):
660
raise NoPushSupport()
661
662
def _get_new_refs(self, stop_revision=None):
989
def _get_new_refs(self, stop_revision=None, fetch_tags=None):
990
assert self.source.is_locked()
663
991
if stop_revision is None:
664
stop_revision = self.source.last_revision()
992
(stop_revno, stop_revision) = self.source.last_revision_info()
993
else:
994
stop_revno = self.source.revision_id_to_revno(stop_revision)
665
995
assert type(stop_revision) is str
666
996
main_ref = self.target.ref or "refs/heads/master"
667
997
refs = { main_ref: (None, stop_revision) }
998
if fetch_tags is None:
999
c = self.source.get_config()
1000
fetch_tags = c.get_user_option_as_bool('branch.fetch_tags')
668
1001
for name, revid in self.source.tags.get_tag_dict().iteritems():
669
1002
if self.source.repository.has_revision(revid):
670
refs[tag_name_to_ref(name)] = (None, revid)
671
return refs, main_ref
1003
ref = tag_name_to_ref(name)
1004
if not check_ref_format(ref):
1005
warning("skipping tag with invalid characters %s (%s)",
1006
name, ref)
1007
continue
1008
if fetch_tags:
1009
# FIXME: Skip tags that are not in the ancestry
1010
refs[ref] = (None, revid)
1011
return refs, main_ref, (stop_revno, stop_revision)
1012
1013
def _update_refs(self, result, old_refs, new_refs, overwrite):
1014
mutter("updating refs. old refs: %r, new refs: %r",
1015
old_refs, new_refs)
1016
result.tag_updates = {}
1017
result.tag_conflicts = []
1018
ret = dict(old_refs)
1019
def ref_equals(refs, ref, git_sha, revid):
1020
try:
1021
value = refs[ref]
1022
except KeyError:
1023
return False
1024
if (value[0] is not None and
1025
git_sha is not None and
1026
value[0] == git_sha):
1027
return True
1028
if (value[1] is not None and
1029
revid is not None and
1030
value[1] == revid):
1031
return True
1032
# FIXME: If one side only has the git sha available and the other only
1033
# has the bzr revid, then this will cause us to show a tag as updated
1034
# that hasn't actually been updated.
1035
return False
1036
# FIXME: Check for diverged branches
1037
for ref, (git_sha, revid) in new_refs.iteritems():
1038
if ref_equals(ret, ref, git_sha, revid):
1039
# Already up to date
1040
if git_sha is None:
1041
git_sha = old_refs[ref][0]
1042
if revid is None:
1043
revid = old_refs[ref][1]
1044
ret[ref] = new_refs[ref] = (git_sha, revid)
1045
elif ref not in ret or overwrite:
1046
try:
1047
tag_name = ref_to_tag_name(ref)
1048
except ValueError:
1049
pass
1050
else:
1051
result.tag_updates[tag_name] = revid
1052
ret[ref] = (git_sha, revid)
1053
else:
1054
# FIXME: Check diverged
1055
diverged = False
1056
if diverged:
1057
try:
1058
name = ref_to_tag_name(ref)
1059
except ValueError:
1060
pass
1061
else:
1062
result.tag_conflicts.append((name, revid, ret[name][1]))
1063
else:
1064
ret[ref] = (git_sha, revid)
1065
return ret
1066
1067
def fetch(self, stop_revision=None, fetch_tags=None, lossy=False, limit=None):
1068
assert limit is None
1069
if stop_revision is None:
1070
stop_revision = self.source.last_revision()
1071
ret = []
1072
if fetch_tags:
1073
for k, v in self.source.tags.get_tag_dict().iteritems():
1074
ret.append((None, v))
1075
ret.append((None, stop_revision))
1076
self.interrepo.fetch_objects(ret, lossy=lossy)
672
1077
673
1078
def pull(self, overwrite=False, stop_revision=None, local=False,
674
possible_transports=None):
675
from dulwich.protocol import ZERO_SHA
1079
possible_transports=None, run_hooks=True):
676
1080
result = GitBranchPullResult()
677
1081
result.source_branch = self.source
678
1082
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]
1083
self.source.lock_read()
1084
try:
1085
self.target.lock_write()
1086
try:
1087
new_refs, main_ref, stop_revinfo = self._get_new_refs(
1088
stop_revision)
1089
def update_refs(old_refs):
1090
return self._update_refs(result, old_refs, new_refs, overwrite)
1091
try:
1092
result.revidmap, old_refs, new_refs = self.interrepo.fetch_refs(
1093
update_refs, lossy=False)
1094
except NoPushSupport:
1095
raise errors.NoRoundtrippingSupport(self.source, self.target)
1096
(old_sha1, result.old_revid) = old_refs.get(main_ref, (ZERO_SHA, NULL_REVISION))
1097
if result.old_revid is None:
1098
result.old_revid = self.target.lookup_foreign_revision_id(old_sha1)
1099
result.new_revid = new_refs[main_ref][1]
1100
result.local_branch = None
1101
result.master_branch = self.target
1102
if run_hooks:
1103
for hook in branch.Branch.hooks['post_pull']:
1104
hook(result)
1105
finally:
1106
self.target.unlock()
1107
finally:
1108
self.source.unlock()
689
1109
return result
690
1110
691
def push(self, overwrite=False, stop_revision=None,
1111
def push(self, overwrite=False, stop_revision=None, lossy=False,
692
1112
_override_hook_source_branch=None):
693
from dulwich.protocol import ZERO_SHA
694
1113
result = GitBranchPushResult()
695
1114
result.source_branch = self.source
696
1115
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]
1116
result.local_branch = None
1117
result.master_branch = result.target_branch
1118
self.source.lock_read()
1119
try:
1120
new_refs, main_ref, stop_revinfo = self._get_new_refs(stop_revision)
1121
def update_refs(old_refs):
1122
return self._update_refs(result, old_refs, new_refs, overwrite)
1123
try:
1124
result.revidmap, old_refs, new_refs = self.interrepo.fetch_refs(
1125
update_refs, lossy=lossy)
1126
except NoPushSupport:
1127
raise errors.NoRoundtrippingSupport(self.source, self.target)
1128
(old_sha1, result.old_revid) = old_refs.get(main_ref, (ZERO_SHA, NULL_REVISION))
1129
if result.old_revid is None:
1130
result.old_revid = self.target.lookup_foreign_revision_id(old_sha1)
1131
result.new_revid = new_refs[main_ref][1]
1132
(result.new_original_revno, result.new_original_revid) = stop_revinfo
1133
for hook in branch.Branch.hooks['post_push']:
1134
hook(result)
1135
finally:
1136
self.source.unlock()
708
1137
return result
709
1138
710
1139
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)
1140
# For compatibility with bzr < 2.4
1141
return self.push(lossy=True, stop_revision=stop_revision)
1142
1143
1144
branch.InterBranch.register_optimiser(InterGitLocalGitBranch)
728
1145
branch.InterBranch.register_optimiser(InterFromGitBranch)
729
1146
branch.InterBranch.register_optimiser(InterToGitBranch)
730
branch.InterBranch.register_optimiser(InterGitLocalRemoteBranch)
1147
branch.InterBranch.register_optimiser(InterLocalGitRemoteGitBranch)
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0