« back to all changes in this revision
Viewing changes to branch.py
- browse files at revision 57
- compare with another revision
- download diff
- download tarball
- view history from revision 57
- Committer: Jelmer Vernooij
- Date: 2010-05-22 23:40:04 UTC
- mfrom: (17.25.364 trunk)
- Revision ID: jelmer@samba.org-20100522234004-48r0bfkodp3xspgv
* New upstream release.
* Bump standards version to 3.8.4.
* Bump standards version to 3.8.4.
- files added:
- notes/git-serve.txt
- files modified:
- NEWS
added
removed
branch.py
1
1
# Copyright (C) 2007 Canonical Ltd
2
# Copyright (C) 2009 Jelmer Vernooij <jelmer@samba.org>
2
# Copyright (C) 2009-2010 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
50
50
NoPushSupport,
51
51
NoSuchRef,
52
52
)
53
from bzrlib.plugins.git.refs import (
54
branch_name_to_ref,
55
ref_to_branch_name,
56
extract_tags,
57
tag_name_to_ref,
58
)
53
59
54
60
from bzrlib.foreign import ForeignBranch
55
61
56
62
57
def extract_tags(refs):
58
ret = {}
59
for k,v in refs.iteritems():
60
if k.startswith("refs/tags/") and not k.endswith("^{}"):
61
v = refs.get(k+"^{}", v)
62
ret[k[len("refs/tags/"):]] = v
63
return ret
64
65
66
63
class GitPullResult(branch.PullResult):
67
64
68
65
def _lookup_revno(self, revid):
101
98
mutter("Tag %s points at object %r that is not a commit, "
102
99
"ignoring", k, obj)
103
100
continue
104
ret[k] = self.branch.mapping.revision_id_foreign_to_bzr(v)
101
ret[k] = self.branch.lookup_foreign_revision_id(v)
105
102
return ret
106
103
104
def _set_tag_dict(self, to_dict):
105
extra = set(self.repository._git.get_refs().keys())
106
for k, revid in to_dict.iteritems():
107
name = tag_name_to_ref(k)
108
if name in extra:
109
extra.remove(name)
110
self.set_tag(k, revid)
111
for name in extra:
112
if name.startswith("refs/tags/"):
113
del self.repository._git[name]
114
107
115
def set_tag(self, name, revid):
108
self.repository._git.refs["refs/tags/%s" % name], _ = \
116
self.repository._git.refs[tag_name_to_ref(name)], _ = \
109
117
self.branch.mapping.revision_id_bzr_to_foreign(revid)
110
118
111
119
112
120
class DictTagDict(LocalGitTagDict):
113
121
114
115
122
def __init__(self, branch, tags):
116
123
super(DictTagDict, self).__init__(branch)
117
124
self._tags = tags
120
127
return self._tags
121
128
122
129
123
124
130
class GitBranchFormat(branch.BranchFormat):
125
131
126
132
def get_format_description(self):
144
150
return LocalGitTagDict(branch)
145
151
146
152
153
class GitReadLock(object):
154
155
def __init__(self, unlock):
156
self.unlock = unlock
157
158
159
class GitWriteLock(object):
160
161
def __init__(self, unlock):
162
self.unlock = unlock
163
164
147
165
class GitBranch(ForeignBranch):
148
166
"""An adapter to git repositories for bzr Branch objects."""
149
167
150
def __init__(self, bzrdir, repository, name, lockfiles, tagsdict=None):
168
def __init__(self, bzrdir, repository, ref, lockfiles, tagsdict=None):
151
169
self.repository = repository
152
170
self._format = GitBranchFormat()
153
171
self.control_files = lockfiles
155
173
super(GitBranch, self).__init__(repository.get_mapping())
156
174
if tagsdict is not None:
157
175
self.tags = DictTagDict(self, tagsdict)
158
self.name = name
176
self.ref = ref
177
self.name = ref_to_branch_name(ref)
159
178
self._head = None
160
179
self.base = bzrdir.root_transport.base
161
180
177
196
178
197
:return: Branch nick
179
198
"""
180
return self.name
199
return self.name or "HEAD"
181
200
182
201
def _set_nick(self, nick):
183
202
raise NotImplementedError
185
204
nick = property(_get_nick, _set_nick)
186
205
187
206
def __repr__(self):
188
return "%s(%r, %r)" % (self.__class__.__name__, self.repository.base, self.name)
207
return "<%s(%r, %r)>" % (self.__class__.__name__, self.repository.base,
208
self.ref or "HEAD")
189
209
190
210
def generate_revision_history(self, revid, old_revid=None):
191
211
# FIXME: Check that old_revid is in the ancestry of revid
194
214
195
215
def lock_write(self):
196
216
self.control_files.lock_write()
217
return GitWriteLock(self.unlock)
197
218
198
219
def get_stacked_on_url(self):
199
220
# Git doesn't do stacking (yet...)
210
231
211
232
def lock_read(self):
212
233
self.control_files.lock_read()
234
return GitReadLock(self.unlock)
213
235
214
236
def is_locked(self):
215
237
return self.control_files.is_locked()
225
247
# perhaps should escape this ?
226
248
if self.head is None:
227
249
return revision.NULL_REVISION
228
return self.mapping.revision_id_foreign_to_bzr(self.head)
250
return self.lookup_foreign_revision_id(self.head)
229
251
230
252
def _basic_push(self, target, overwrite=False, stop_revision=None):
231
253
return branch.InterBranch.get(self, target)._basic_push(
232
254
overwrite, stop_revision)
233
255
256
def lookup_foreign_revision_id(self, foreign_revid):
257
return self.repository.lookup_foreign_revision_id(foreign_revid,
258
self.mapping)
259
234
260
235
261
class LocalGitBranch(GitBranch):
236
262
"""A local Git branch."""
237
263
264
def __init__(self, bzrdir, repository, name, lockfiles, tagsdict=None):
265
super(LocalGitBranch, self).__init__(bzrdir, repository, name,
266
lockfiles, tagsdict)
267
refs = repository._git.get_refs()
268
if not (name in refs.keys() or "HEAD" in refs.keys()):
269
raise errors.NotBranchError(self.base)
270
238
271
def create_checkout(self, to_location, revision_id=None, lightweight=False,
239
272
accelerator_tree=None, hardlink=False):
240
273
if lightweight:
279
312
280
313
def _get_head(self):
281
314
try:
282
return self.repository._git.ref(self.name)
315
return self.repository._git.ref(self.ref or "HEAD")
283
316
except KeyError:
284
317
return None
285
318
287
320
self.set_last_revision(revid)
288
321
289
322
def set_last_revision(self, revid):
290
(newhead, self.mapping) = self.mapping.revision_id_bzr_to_foreign(
291
revid)
323
(newhead, self.mapping) = self.repository.lookup_bzr_revision_id(revid)
292
324
self.head = newhead
293
325
294
326
def _set_head(self, value):
295
327
self._head = value
296
self.repository._git.refs[self.name] = self._head
328
self.repository._git.refs[self.ref or "HEAD"] = self._head
297
329
self._clear_cached_state()
298
330
299
331
head = property(_get_head, _set_head)
313
345
314
346
def supports_tags(self):
315
347
return True
316
348
317
349
318
350
class GitBranchPullResult(branch.PullResult):
319
351
352
def __init__(self):
353
super(GitBranchPullResult, self).__init__()
354
self.new_git_head = None
355
self._old_revno = None
356
self._new_revno = None
357
320
358
def report(self, to_file):
321
359
if not is_quiet():
322
360
if self.old_revid == self.new_revid:
323
361
to_file.write('No revisions to pull.\n')
324
else:
362
elif self.new_git_head is not None:
325
363
to_file.write('Now on revision %d (git sha: %s).\n' %
326
364
(self.new_revno, self.new_git_head))
365
else:
366
to_file.write('Now on revision %d.\n' % (self.new_revno,))
327
367
self._show_tag_conficts(to_file)
328
368
369
def _lookup_revno(self, revid):
370
assert isinstance(revid, str), "was %r" % revid
371
# Try in source branch first, it'll be faster
372
try:
373
return self.source_branch.revision_id_to_revno(revid)
374
except errors.NoSuchRevision:
375
# FIXME: Check using graph.find_distance_to_null() ?
376
return self.target_branch.revision_id_to_revno(revid)
377
378
def _get_old_revno(self):
379
if self._old_revno is not None:
380
return self._old_revno
381
return self._lookup_revno(self.old_revid)
382
383
def _set_old_revno(self, revno):
384
self._old_revno = revno
385
386
old_revno = property(_get_old_revno, _set_old_revno)
387
388
def _get_new_revno(self):
389
if self._new_revno is not None:
390
return self._new_revno
391
return self._lookup_revno(self.new_revid)
392
393
def _set_new_revno(self, revno):
394
self._new_revno = revno
395
396
new_revno = property(_get_new_revno, _set_new_revno)
397
329
398
330
399
class GitBranchPushResult(branch.BranchPushResult):
331
400
361
430
not isinstance(target, GitBranch) and
362
431
(getattr(cls._get_interrepo(source, target), "fetch_objects", None) is not None))
363
432
364
def update_revisions(self, stop_revision=None, overwrite=False,
365
graph=None):
366
"""See InterBranch.update_revisions()."""
433
def _update_revisions(self, stop_revision=None, overwrite=False,
434
graph=None, limit=None):
435
"""Like InterBranch.update_revisions(), but with additions.
436
437
Compared to the `update_revisions()` below, this function takes a
438
`limit` argument that limits how many git commits will be converted
439
and returns the new git head.
440
"""
367
441
interrepo = self._get_interrepo(self.source, self.target)
368
self._head = None
369
self._last_revid = None
370
442
def determine_wants(heads):
371
if not self.source.name in heads:
372
raise NoSuchRef(self.source.name, heads.keys())
443
if self.source.ref is not None and not self.source.ref in heads:
444
raise NoSuchRef(self.source.ref, heads.keys())
373
445
if stop_revision is not None:
374
446
self._last_revid = stop_revision
375
self._head, mapping = self.source.repository.lookup_bzr_revision_id(
447
head, mapping = self.source.repository.lookup_bzr_revision_id(
376
448
stop_revision)
377
449
else:
378
self._head = heads[self.source.name]
379
self._last_revid = \
380
self.source.mapping.revision_id_foreign_to_bzr(self._head)
450
if self.source.ref is not None:
451
head = heads[self.source.ref]
452
else:
453
head = heads["HEAD"]
454
self._last_revid = self.source.lookup_foreign_revision_id(head)
381
455
if self.target.repository.has_revision(self._last_revid):
382
456
return []
383
return [self._head]
384
interrepo.fetch_objects(determine_wants, self.source.mapping)
457
return [head]
458
pack_hint, head = interrepo.fetch_objects(
459
determine_wants, self.source.mapping, limit=limit)
460
if (pack_hint is not None and
461
self.target.repository._format.pack_compresses):
462
self.target.repository.pack(hint=pack_hint)
463
if head is not None:
464
self._last_revid = self.source.lookup_foreign_revision_id(head)
385
465
if overwrite:
386
466
prev_last_revid = None
387
467
else:
388
468
prev_last_revid = self.target.last_revision()
389
self.target.generate_revision_history(self._last_revid, prev_last_revid)
469
self.target.generate_revision_history(self._last_revid,
470
prev_last_revid)
471
return head
472
473
def update_revisions(self, stop_revision=None, overwrite=False,
474
graph=None):
475
"""See InterBranch.update_revisions()."""
476
self._update_revisions(stop_revision, overwrite, graph)
390
477
391
478
def pull(self, overwrite=False, stop_revision=None,
392
479
possible_transports=None, _hook_master=None, run_hooks=True,
393
_override_hook_target=None, local=False):
480
_override_hook_target=None, local=False, limit=None):
394
481
"""See Branch.pull.
395
482
396
483
:param _hook_master: Private parameter - set the branch to
400
487
so it should not run its hooks.
401
488
:param _override_hook_target: Private parameter - set the branch to be
402
489
supplied as the target_branch to pull hooks.
490
:param limit: Only import this many revisons. `None`, the default,
491
means import all revisions.
403
492
"""
404
493
# This type of branch can't be bound.
405
494
if local:
415
504
# We assume that during 'pull' the target repository is closer than
416
505
# the source one.
417
506
graph = self.target.repository.get_graph(self.source.repository)
418
result.old_revno, result.old_revid = \
507
(result.old_revno, result.old_revid) = \
419
508
self.target.last_revision_info()
420
self.update_revisions(stop_revision, overwrite=overwrite,
421
graph=graph)
422
result.new_git_head = self._head
509
result.new_git_head = self._update_revisions(
510
stop_revision, overwrite=overwrite, graph=graph, limit=limit)
423
511
result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
424
512
overwrite)
425
result.new_revno, result.new_revid = self.target.last_revision_info()
513
(result.new_revno, result.new_revid) = \
514
self.target.last_revision_info()
426
515
if _hook_master:
427
516
result.master_branch = _hook_master
428
517
result.local_branch = result.target_branch
442
531
result.target_branch = self.target
443
532
graph = self.target.repository.get_graph(self.source.repository)
444
533
result.old_revno, result.old_revid = self.target.last_revision_info()
445
self.update_revisions(stop_revision, overwrite=overwrite, graph=graph)
446
result.new_git_head = self._head
534
result.new_git_head = self._update_revisions(
535
stop_revision, overwrite=overwrite, graph=graph)
447
536
result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
448
537
overwrite)
449
538
result.new_revno, result.new_revid = self.target.last_revision_info()
464
553
isinstance(target, RemoteGitBranch))
465
554
466
555
def _basic_push(self, overwrite=False, stop_revision=None):
556
from dulwich.protocol import ZERO_SHA
467
557
result = GitBranchPushResult()
468
558
result.source_branch = self.source
469
559
result.target_branch = self.target
471
561
stop_revision = self.source.last_revision()
472
562
# FIXME: Check for diverged branches
473
563
def get_changed_refs(old_refs):
474
result.old_revid = self.target.mapping.revision_id_foreign_to_bzr(old_refs.get("refs/heads/master", "0" * 40))
475
refs = { "refs/heads/master": self.source.repository.lookup_bzr_revision_id(stop_revision)[0] }
564
result.old_revid = self.target.lookup_foreign_revision_id(old_refs.get(self.target.ref, ZERO_SHA))
565
refs = { self.target.ref: self.source.repository.lookup_bzr_revision_id(stop_revision)[0] }
476
566
result.new_revid = stop_revision
477
567
for name, sha in self.source.repository._git.refs.as_dict("refs/tags").iteritems():
478
refs["refs/tags/%s" % name] = sha
568
refs[tag_name_to_ref(name)] = sha
479
569
return refs
480
570
self.target.repository.send_pack(get_changed_refs,
481
self.source.repository._git.object_store.generate_pack_contents)
571
self.source.repository._git.object_store.generate_pack_contents)
482
572
return result
483
573
484
574
504
594
505
595
def update_tags(self, refs):
506
596
for name, v in extract_tags(refs).iteritems():
507
revid = self.target.mapping.revision_id_foreign_to_bzr(v)
597
revid = self.target.lookup_foreign_revision_id(v)
508
598
self.target.tags.set_tag(name, revid)
509
599
510
600
def update_refs(self, stop_revision=None):
512
602
self.target.repository)
513
603
if stop_revision is None:
514
604
refs = interrepo.fetch_refs(branches=["HEAD"])
515
stop_revision = self.target.mapping.revision_id_foreign_to_bzr(refs["HEAD"])
605
stop_revision = self.target.lookup_foreign_revision_id(refs["HEAD"])
516
606
else:
517
607
refs = interrepo.fetch_refs(revision_id=stop_revision)
518
608
return refs, stop_revision
519
609
520
610
def pull(self, stop_revision=None, overwrite=False,
521
possible_transports=None, local=False):
611
possible_transports=None, run_hooks=True,local=False):
522
612
# This type of branch can't be bound.
523
613
if local:
524
614
raise errors.LocalRequiresBoundBranch()
548
638
def update_revisions(self, *args, **kwargs):
549
639
raise NoPushSupport()
550
640
551
def push(self, overwrite=True, stop_revision=None,
641
def _get_new_refs(self, stop_revision=None):
642
if stop_revision is None:
643
stop_revision = self.source.last_revision()
644
main_ref = self.target.ref or "refs/heads/master"
645
refs = { main_ref: stop_revision }
646
for name, revid in self.source.tags.get_tag_dict().iteritems():
647
if self.source.repository.has_revision(revid):
648
refs[tag_name_to_ref(name)] = revid
649
return refs, main_ref
650
651
def pull(self, overwrite=False, stop_revision=None, local=False,
652
possible_transports=None):
653
from dulwich.protocol import ZERO_SHA
654
result = GitBranchPullResult()
655
result.source_branch = self.source
656
result.target_branch = self.target
657
# FIXME: Check for diverged branches
658
old_refs = self.target.repository._git.get_refs()
659
refs = dict(old_refs)
660
new_refs, main_ref = self._get_new_refs(stop_revision)
661
refs.update(new_refs)
662
self.target.repository.fetch_refs(self.source.repository, refs)
663
result.old_revid = self.target.lookup_foreign_revision_id(
664
old_refs.get(main_ref, ZERO_SHA))
665
result.new_revid = refs[main_ref]
666
return result
667
668
def push(self, overwrite=False, stop_revision=None,
552
669
_override_hook_source_branch=None):
553
raise NoPushSupport()
670
from dulwich.protocol import ZERO_SHA
671
result = GitBranchPushResult()
672
result.source_branch = self.source
673
result.target_branch = self.target
674
# FIXME: Check for diverged branches
675
old_refs = self.target.repository._git.get_refs()
676
refs = dict(old_refs)
677
new_refs, main_ref = self._get_new_refs(stop_revision)
678
refs.update(new_refs)
679
self.target.repository.fetch_refs(self.source.repository, refs)
680
result.old_revid = self.target.lookup_foreign_revision_id(
681
old_refs.get(main_ref, ZERO_SHA))
682
result.new_revid = refs[main_ref]
683
return result
554
684
555
685
def lossy_push(self, stop_revision=None):
686
from dulwich.protocol import ZERO_SHA
556
687
result = GitBranchPushResult()
557
688
result.source_branch = self.source
558
689
result.target_branch = self.target
559
try:
560
result.old_revid = self.target.last_revision()
561
except NoSuchRef:
562
result.old_revid = revision.NULL_REVISION
563
if stop_revision is None:
564
stop_revision = self.source.last_revision()
565
690
# FIXME: Check for diverged branches
566
refs = { "refs/heads/master": stop_revision }
567
for name, revid in self.source.tags.get_tag_dict().iteritems():
568
if self.source.repository.has_revision(revid):
569
refs["refs/tags/%s" % name] = revid
570
revidmap, new_refs = self.target.repository.dfetch_refs(
691
refs, main_ref = self._get_new_refs(stop_revision)
692
result.revidmap, old_refs, new_refs = self.target.repository.dfetch_refs(
571
693
self.source.repository, refs)
572
if revidmap != {}:
573
self.target.generate_revision_history(revidmap[stop_revision])
574
result.new_revid = revidmap[stop_revision]
575
else:
576
result.new_revid = result.old_revid
577
result.revidmap = revidmap
694
result.old_revid = self.target.lookup_foreign_revision_id(
695
old_refs.get(self.target.ref, ZERO_SHA))
696
result.new_revid = self.target.lookup_foreign_revision_id(
697
new_refs[main_ref])
578
698
return result
579
699
580
700
Loggerhead is a web-based interface for Breezy
Version: 2.0.1