52
66
from bzrlib.trace import mutter, mutter_callsite, note, is_quiet
55
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
56
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
57
BZR_BRANCH_FORMAT_6 = "Bazaar Branch Format 6 (bzr 0.15)\n"
60
# TODO: Maybe include checks for common corruption of newlines, etc?
62
# TODO: Some operations like log might retrieve the same revisions
63
# repeatedly to calculate deltas. We could perhaps have a weakref
64
# cache in memory to make this faster. In general anything can be
65
# cached in memory between lock and unlock operations. .. nb thats
66
# what the transaction identity map provides
69
######################################################################
69
class Branch(controldir.ControlComponent):
73
70
"""Branch holding a history of revisions.
76
Base directory/url of the branch.
78
hooks: An instance of BranchHooks.
73
Base directory/url of the branch; using control_url and
74
control_transport is more standardized.
75
:ivar hooks: An instance of BranchHooks.
76
:ivar _master_branch_cache: cached result of get_master_branch, see
80
79
# this is really an instance variable - FIXME move it there
84
# override this to set the strategy for storing tags
86
return DisabledTags(self)
84
def control_transport(self):
85
return self._transport
88
def user_transport(self):
89
return self.bzrdir.user_transport
88
91
def __init__(self, *ignored, **ignored_too):
89
self.tags = self._make_tags()
92
self.tags = self._format.make_tags(self)
90
93
self._revision_history_cache = None
91
94
self._revision_id_to_revno_cache = None
95
self._partial_revision_id_to_revno_cache = {}
96
self._partial_revision_history_cache = []
97
self._tags_bytes = None
92
98
self._last_revision_info_cache = None
99
self._master_branch_cache = None
100
self._merge_sorted_revisions_cache = None
102
hooks = Branch.hooks['open']
95
106
def _open_hook(self):
96
107
"""Called by init to allow simpler extension of the base class."""
109
def _activate_fallback_location(self, url):
110
"""Activate the branch/repository from url as a fallback repository."""
111
for existing_fallback_repo in self.repository._fallback_repositories:
112
if existing_fallback_repo.user_url == url:
113
# This fallback is already configured. This probably only
114
# happens because BzrDir.sprout is a horrible mess. To avoid
115
# confusing _unstack we don't add this a second time.
116
mutter('duplicate activation of fallback %r on %r', url, self)
118
repo = self._get_fallback_repository(url)
119
if repo.has_same_location(self.repository):
120
raise errors.UnstackableLocationError(self.user_url, url)
121
self.repository.add_fallback_repository(repo)
98
123
def break_lock(self):
99
124
"""Break a lock if one is present from another instance.
142
201
possible_transports)
143
202
return control.open_branch(), relpath
204
def _push_should_merge_tags(self):
205
"""Should _basic_push merge this branch's tags into the target?
207
The default implementation returns False if this branch has no tags,
208
and True the rest of the time. Subclasses may override this.
210
return self.supports_tags() and self.tags.get_tag_dict()
145
212
def get_config(self):
213
"""Get a bzrlib.config.BranchConfig for this Branch.
215
This can then be used to get and set configuration options for the
218
:return: A bzrlib.config.BranchConfig.
146
220
return BranchConfig(self)
149
return self.get_config().get_nickname()
222
def _get_config(self):
223
"""Get the concrete config for just the config in this branch.
225
This is not intended for client use; see Branch.get_config for the
230
:return: An object supporting get_option and set_option.
232
raise NotImplementedError(self._get_config)
234
def _get_fallback_repository(self, url):
235
"""Get the repository we fallback to at url."""
236
url = urlutils.join(self.base, url)
237
a_branch = Branch.open(url,
238
possible_transports=[self.bzrdir.root_transport])
239
return a_branch.repository
242
def _get_tags_bytes(self):
243
"""Get the bytes of a serialised tags dict.
245
Note that not all branches support tags, nor do all use the same tags
246
logic: this method is specific to BasicTags. Other tag implementations
247
may use the same method name and behave differently, safely, because
248
of the double-dispatch via
249
format.make_tags->tags_instance->get_tags_dict.
251
:return: The bytes of the tags file.
252
:seealso: Branch._set_tags_bytes.
254
if self._tags_bytes is None:
255
self._tags_bytes = self._transport.get_bytes('tags')
256
return self._tags_bytes
258
def _get_nick(self, local=False, possible_transports=None):
259
config = self.get_config()
260
# explicit overrides master, but don't look for master if local is True
261
if not local and not config.has_explicit_nickname():
263
master = self.get_master_branch(possible_transports)
264
if master and self.user_url == master.user_url:
265
raise errors.RecursiveBind(self.user_url)
266
if master is not None:
267
# return the master branch value
269
except errors.RecursiveBind, e:
271
except errors.BzrError, e:
272
# Silently fall back to local implicit nick if the master is
274
mutter("Could not connect to bound branch, "
275
"falling back to local nick.\n " + str(e))
276
return config.get_nickname()
151
278
def _set_nick(self, nick):
152
279
self.get_config().set_user_option('nickname', nick, warn_masked=True)
203
431
:return: A dictionary mapping revision_id => dotted revno.
205
last_revision = self.last_revision()
206
revision_graph = repository._old_get_graph(self.repository,
208
merge_sorted_revisions = tsort.merge_sort(
213
433
revision_id_to_revno = dict((rev_id, revno)
214
for seq_num, rev_id, depth, revno, end_of_merge
215
in merge_sorted_revisions)
434
for rev_id, depth, revno, end_of_merge
435
in self.iter_merge_sorted_revisions())
216
436
return revision_id_to_revno
439
def iter_merge_sorted_revisions(self, start_revision_id=None,
440
stop_revision_id=None, stop_rule='exclude', direction='reverse'):
441
"""Walk the revisions for a branch in merge sorted order.
443
Merge sorted order is the output from a merge-aware,
444
topological sort, i.e. all parents come before their
445
children going forward; the opposite for reverse.
447
:param start_revision_id: the revision_id to begin walking from.
448
If None, the branch tip is used.
449
:param stop_revision_id: the revision_id to terminate the walk
450
after. If None, the rest of history is included.
451
:param stop_rule: if stop_revision_id is not None, the precise rule
452
to use for termination:
454
* 'exclude' - leave the stop revision out of the result (default)
455
* 'include' - the stop revision is the last item in the result
456
* 'with-merges' - include the stop revision and all of its
457
merged revisions in the result
458
* 'with-merges-without-common-ancestry' - filter out revisions
459
that are in both ancestries
460
:param direction: either 'reverse' or 'forward':
462
* reverse means return the start_revision_id first, i.e.
463
start at the most recent revision and go backwards in history
464
* forward returns tuples in the opposite order to reverse.
465
Note in particular that forward does *not* do any intelligent
466
ordering w.r.t. depth as some clients of this API may like.
467
(If required, that ought to be done at higher layers.)
469
:return: an iterator over (revision_id, depth, revno, end_of_merge)
472
* revision_id: the unique id of the revision
473
* depth: How many levels of merging deep this node has been
475
* revno_sequence: This field provides a sequence of
476
revision numbers for all revisions. The format is:
477
(REVNO, BRANCHNUM, BRANCHREVNO). BRANCHNUM is the number of the
478
branch that the revno is on. From left to right the REVNO numbers
479
are the sequence numbers within that branch of the revision.
480
* end_of_merge: When True the next node (earlier in history) is
481
part of a different merge.
483
# Note: depth and revno values are in the context of the branch so
484
# we need the full graph to get stable numbers, regardless of the
486
if self._merge_sorted_revisions_cache is None:
487
last_revision = self.last_revision()
488
known_graph = self.repository.get_known_graph_ancestry(
490
self._merge_sorted_revisions_cache = known_graph.merge_sort(
492
filtered = self._filter_merge_sorted_revisions(
493
self._merge_sorted_revisions_cache, start_revision_id,
494
stop_revision_id, stop_rule)
495
# Make sure we don't return revisions that are not part of the
496
# start_revision_id ancestry.
497
filtered = self._filter_start_non_ancestors(filtered)
498
if direction == 'reverse':
500
if direction == 'forward':
501
return reversed(list(filtered))
503
raise ValueError('invalid direction %r' % direction)
505
def _filter_merge_sorted_revisions(self, merge_sorted_revisions,
506
start_revision_id, stop_revision_id, stop_rule):
507
"""Iterate over an inclusive range of sorted revisions."""
508
rev_iter = iter(merge_sorted_revisions)
509
if start_revision_id is not None:
510
for node in rev_iter:
512
if rev_id != start_revision_id:
515
# The decision to include the start or not
516
# depends on the stop_rule if a stop is provided
517
# so pop this node back into the iterator
518
rev_iter = chain(iter([node]), rev_iter)
520
if stop_revision_id is None:
522
for node in rev_iter:
524
yield (rev_id, node.merge_depth, node.revno,
526
elif stop_rule == 'exclude':
527
for node in rev_iter:
529
if rev_id == stop_revision_id:
531
yield (rev_id, node.merge_depth, node.revno,
533
elif stop_rule == 'include':
534
for node in rev_iter:
536
yield (rev_id, node.merge_depth, node.revno,
538
if rev_id == stop_revision_id:
540
elif stop_rule == 'with-merges-without-common-ancestry':
541
# We want to exclude all revisions that are already part of the
542
# stop_revision_id ancestry.
543
graph = self.repository.get_graph()
544
ancestors = graph.find_unique_ancestors(start_revision_id,
546
for node in rev_iter:
548
if rev_id not in ancestors:
550
yield (rev_id, node.merge_depth, node.revno,
552
elif stop_rule == 'with-merges':
553
stop_rev = self.repository.get_revision(stop_revision_id)
554
if stop_rev.parent_ids:
555
left_parent = stop_rev.parent_ids[0]
557
left_parent = _mod_revision.NULL_REVISION
558
# left_parent is the actual revision we want to stop logging at,
559
# since we want to show the merged revisions after the stop_rev too
560
reached_stop_revision_id = False
561
revision_id_whitelist = []
562
for node in rev_iter:
564
if rev_id == left_parent:
565
# reached the left parent after the stop_revision
567
if (not reached_stop_revision_id or
568
rev_id in revision_id_whitelist):
569
yield (rev_id, node.merge_depth, node.revno,
571
if reached_stop_revision_id or rev_id == stop_revision_id:
572
# only do the merged revs of rev_id from now on
573
rev = self.repository.get_revision(rev_id)
575
reached_stop_revision_id = True
576
revision_id_whitelist.extend(rev.parent_ids)
578
raise ValueError('invalid stop_rule %r' % stop_rule)
580
def _filter_start_non_ancestors(self, rev_iter):
581
# If we started from a dotted revno, we want to consider it as a tip
582
# and don't want to yield revisions that are not part of its
583
# ancestry. Given the order guaranteed by the merge sort, we will see
584
# uninteresting descendants of the first parent of our tip before the
586
first = rev_iter.next()
587
(rev_id, merge_depth, revno, end_of_merge) = first
590
# We start at a mainline revision so by definition, all others
591
# revisions in rev_iter are ancestors
592
for node in rev_iter:
597
pmap = self.repository.get_parent_map([rev_id])
598
parents = pmap.get(rev_id, [])
600
whitelist.update(parents)
602
# If there is no parents, there is nothing of interest left
604
# FIXME: It's hard to test this scenario here as this code is never
605
# called in that case. -- vila 20100322
608
for (rev_id, merge_depth, revno, end_of_merge) in rev_iter:
610
if rev_id in whitelist:
611
pmap = self.repository.get_parent_map([rev_id])
612
parents = pmap.get(rev_id, [])
613
whitelist.remove(rev_id)
614
whitelist.update(parents)
616
# We've reached the mainline, there is nothing left to
620
# A revision that is not part of the ancestry of our
623
yield (rev_id, merge_depth, revno, end_of_merge)
218
625
def leave_lock_in_place(self):
219
626
"""Tell this branch object not to release the physical lock when this
220
627
object is unlocked.
222
629
If lock_write doesn't return a token, then this method is not supported.
224
631
self.control_files.leave_in_place()
337
743
"""Print `file` to stdout."""
338
744
raise NotImplementedError(self.print_file)
746
@deprecated_method(deprecated_in((2, 4, 0)))
340
747
def set_revision_history(self, rev_history):
341
raise NotImplementedError(self.set_revision_history)
748
"""See Branch.set_revision_history."""
749
self._set_revision_history(rev_history)
752
def _set_revision_history(self, rev_history):
753
if len(rev_history) == 0:
754
revid = _mod_revision.NULL_REVISION
756
revid = rev_history[-1]
757
if rev_history != self._lefthand_history(revid):
758
raise errors.NotLefthandHistory(rev_history)
759
self.set_last_revision_info(len(rev_history), revid)
760
self._cache_revision_history(rev_history)
761
for hook in Branch.hooks['set_rh']:
762
hook(self, rev_history)
765
def set_last_revision_info(self, revno, revision_id):
766
"""Set the last revision of this branch.
768
The caller is responsible for checking that the revno is correct
769
for this revision id.
771
It may be possible to set the branch last revision to an id not
772
present in the repository. However, branches can also be
773
configured to check constraints on history, in which case this may not
776
raise NotImplementedError(self.set_last_revision_info)
779
def generate_revision_history(self, revision_id, last_rev=None,
781
"""See Branch.generate_revision_history"""
782
graph = self.repository.get_graph()
783
(last_revno, last_revid) = self.last_revision_info()
784
known_revision_ids = [
785
(last_revid, last_revno),
786
(_mod_revision.NULL_REVISION, 0),
788
if last_rev is not None:
789
if not graph.is_ancestor(last_rev, revision_id):
790
# our previous tip is not merged into stop_revision
791
raise errors.DivergedBranches(self, other_branch)
792
revno = graph.find_distance_to_null(revision_id, known_revision_ids)
793
self.set_last_revision_info(revno, revision_id)
796
def set_parent(self, url):
797
"""See Branch.set_parent."""
798
# TODO: Maybe delete old location files?
799
# URLs should never be unicode, even on the local fs,
800
# FIXUP this and get_parent in a future branch format bump:
801
# read and rewrite the file. RBC 20060125
803
if isinstance(url, unicode):
805
url = url.encode('ascii')
806
except UnicodeEncodeError:
807
raise errors.InvalidURL(url,
808
"Urls must be 7-bit ascii, "
809
"use bzrlib.urlutils.escape")
810
url = urlutils.relative_url(self.base, url)
811
self._set_parent_location(url)
343
814
def set_stacked_on_url(self, url):
344
815
"""Set the URL this branch is stacked against.
348
819
:raises UnstackableRepositoryFormat: If the repository does not support
351
raise NotImplementedError(self.set_stacked_on_url)
822
if not self._format.supports_stacking():
823
raise errors.UnstackableBranchFormat(self._format, self.user_url)
824
# XXX: Changing from one fallback repository to another does not check
825
# that all the data you need is present in the new fallback.
826
# Possibly it should.
827
self._check_stackable_repo()
830
old_url = self.get_stacked_on_url()
831
except (errors.NotStacked, errors.UnstackableBranchFormat,
832
errors.UnstackableRepositoryFormat):
836
self._activate_fallback_location(url)
837
# write this out after the repository is stacked to avoid setting a
838
# stacked config that doesn't work.
839
self._set_config_location('stacked_on_location', url)
842
"""Change a branch to be unstacked, copying data as needed.
844
Don't call this directly, use set_stacked_on_url(None).
846
pb = ui.ui_factory.nested_progress_bar()
848
pb.update("Unstacking")
849
# The basic approach here is to fetch the tip of the branch,
850
# including all available ghosts, from the existing stacked
851
# repository into a new repository object without the fallbacks.
853
# XXX: See <https://launchpad.net/bugs/397286> - this may not be
854
# correct for CHKMap repostiories
855
old_repository = self.repository
856
if len(old_repository._fallback_repositories) != 1:
857
raise AssertionError("can't cope with fallback repositories "
858
"of %r (fallbacks: %r)" % (old_repository,
859
old_repository._fallback_repositories))
860
# Open the new repository object.
861
# Repositories don't offer an interface to remove fallback
862
# repositories today; take the conceptually simpler option and just
863
# reopen it. We reopen it starting from the URL so that we
864
# get a separate connection for RemoteRepositories and can
865
# stream from one of them to the other. This does mean doing
866
# separate SSH connection setup, but unstacking is not a
867
# common operation so it's tolerable.
868
new_bzrdir = bzrdir.BzrDir.open(self.bzrdir.root_transport.base)
869
new_repository = new_bzrdir.find_repository()
870
if new_repository._fallback_repositories:
871
raise AssertionError("didn't expect %r to have "
872
"fallback_repositories"
873
% (self.repository,))
874
# Replace self.repository with the new repository.
875
# Do our best to transfer the lock state (i.e. lock-tokens and
876
# lock count) of self.repository to the new repository.
877
lock_token = old_repository.lock_write().repository_token
878
self.repository = new_repository
879
if isinstance(self, remote.RemoteBranch):
880
# Remote branches can have a second reference to the old
881
# repository that need to be replaced.
882
if self._real_branch is not None:
883
self._real_branch.repository = new_repository
884
self.repository.lock_write(token=lock_token)
885
if lock_token is not None:
886
old_repository.leave_lock_in_place()
887
old_repository.unlock()
888
if lock_token is not None:
889
# XXX: self.repository.leave_lock_in_place() before this
890
# function will not be preserved. Fortunately that doesn't
891
# affect the current default format (2a), and would be a
892
# corner-case anyway.
893
# - Andrew Bennetts, 2010/06/30
894
self.repository.dont_leave_lock_in_place()
898
old_repository.unlock()
899
except errors.LockNotHeld:
902
if old_lock_count == 0:
903
raise AssertionError(
904
'old_repository should have been locked at least once.')
905
for i in range(old_lock_count-1):
906
self.repository.lock_write()
907
# Fetch from the old repository into the new.
908
old_repository.lock_read()
910
# XXX: If you unstack a branch while it has a working tree
911
# with a pending merge, the pending-merged revisions will no
912
# longer be present. You can (probably) revert and remerge.
914
tags_to_fetch = set(self.tags.get_reverse_tag_dict())
915
except errors.TagsNotSupported:
916
tags_to_fetch = set()
917
fetch_spec = _mod_graph.NotInOtherForRevs(self.repository,
918
old_repository, required_ids=[self.last_revision()],
919
if_present_ids=tags_to_fetch, find_ghosts=True).execute()
920
self.repository.fetch(old_repository, fetch_spec=fetch_spec)
922
old_repository.unlock()
926
def _set_tags_bytes(self, bytes):
927
"""Mirror method for _get_tags_bytes.
929
:seealso: Branch._get_tags_bytes.
931
op = cleanup.OperationWithCleanups(self._set_tags_bytes_locked)
932
op.add_cleanup(self.lock_write().unlock)
933
return op.run_simple(bytes)
935
def _set_tags_bytes_locked(self, bytes):
936
self._tags_bytes = bytes
937
return self._transport.put_bytes('tags', bytes)
353
939
def _cache_revision_history(self, rev_history):
354
940
"""Set the cached revision history to rev_history.
440
1027
:return: A tuple (revno, revision_id).
442
1029
if self._last_revision_info_cache is None:
443
self._last_revision_info_cache = self._last_revision_info()
1030
self._last_revision_info_cache = self._read_last_revision_info()
444
1031
return self._last_revision_info_cache
446
def _last_revision_info(self):
447
rh = self.revision_history()
450
return (revno, rh[-1])
452
return (0, _mod_revision.NULL_REVISION)
454
@deprecated_method(deprecated_in((1, 6, 0)))
455
def missing_revisions(self, other, stop_revision=None):
456
"""Return a list of new revisions that would perfectly fit.
458
If self and other have not diverged, return a list of the revisions
459
present in other, but missing from self.
461
self_history = self.revision_history()
462
self_len = len(self_history)
463
other_history = other.revision_history()
464
other_len = len(other_history)
465
common_index = min(self_len, other_len) -1
466
if common_index >= 0 and \
467
self_history[common_index] != other_history[common_index]:
468
raise errors.DivergedBranches(self, other)
470
if stop_revision is None:
471
stop_revision = other_len
473
if stop_revision > other_len:
474
raise errors.NoSuchRevision(self, stop_revision)
475
return other_history[self_len:stop_revision]
478
def update_revisions(self, other, stop_revision=None, overwrite=False,
480
"""Pull in new perfect-fit revisions.
482
:param other: Another Branch to pull from
483
:param stop_revision: Updated until the given revision
484
:param overwrite: Always set the branch pointer, rather than checking
485
to see if it is a proper descendant.
486
:param graph: A Graph object that can be used to query history
487
information. This can be None.
492
other_revno, other_last_revision = other.last_revision_info()
493
stop_revno = None # unknown
494
if stop_revision is None:
495
stop_revision = other_last_revision
496
if _mod_revision.is_null(stop_revision):
497
# if there are no commits, we're done.
499
stop_revno = other_revno
501
# what's the current last revision, before we fetch [and change it
503
last_rev = _mod_revision.ensure_null(self.last_revision())
504
# we fetch here so that we don't process data twice in the common
505
# case of having something to pull, and so that the check for
506
# already merged can operate on the just fetched graph, which will
507
# be cached in memory.
508
self.fetch(other, stop_revision)
509
# Check to see if one is an ancestor of the other
512
graph = self.repository.get_graph()
513
if self._check_if_descendant_or_diverged(
514
stop_revision, last_rev, graph, other):
515
# stop_revision is a descendant of last_rev, but we aren't
516
# overwriting, so we're done.
518
if stop_revno is None:
520
graph = self.repository.get_graph()
521
this_revno, this_last_revision = self.last_revision_info()
522
stop_revno = graph.find_distance_to_null(stop_revision,
523
[(other_last_revision, other_revno),
524
(this_last_revision, this_revno)])
525
self.set_last_revision_info(stop_revno, stop_revision)
1033
def _read_last_revision_info(self):
1034
raise NotImplementedError(self._read_last_revision_info)
1036
@deprecated_method(deprecated_in((2, 4, 0)))
1037
def import_last_revision_info(self, source_repo, revno, revid):
1038
"""Set the last revision info, importing from another repo if necessary.
1040
:param source_repo: Source repository to optionally fetch from
1041
:param revno: Revision number of the new tip
1042
:param revid: Revision id of the new tip
1044
if not self.repository.has_same_location(source_repo):
1045
self.repository.fetch(source_repo, revision_id=revid)
1046
self.set_last_revision_info(revno, revid)
1048
def import_last_revision_info_and_tags(self, source, revno, revid,
1050
"""Set the last revision info, importing from another repo if necessary.
1052
This is used by the bound branch code to upload a revision to
1053
the master branch first before updating the tip of the local branch.
1054
Revisions referenced by source's tags are also transferred.
1056
:param source: Source branch to optionally fetch from
1057
:param revno: Revision number of the new tip
1058
:param revid: Revision id of the new tip
1059
:param lossy: Whether to discard metadata that can not be
1060
natively represented
1061
:return: Tuple with the new revision number and revision id
1062
(should only be different from the arguments when lossy=True)
1064
if not self.repository.has_same_location(source.repository):
1065
self.fetch(source, revid)
1066
self.set_last_revision_info(revno, revid)
1067
return (revno, revid)
529
1069
def revision_id_to_revno(self, revision_id):
530
1070
"""Given a revision id, return its revno"""
685
1280
revision_id: if not None, the revision history in the new branch will
686
1281
be truncated to end with revision_id.
688
result = to_bzrdir.create_branch()
689
self.copy_content_into(result, revision_id=revision_id)
690
result.set_parent(self.bzrdir.root_transport.base)
1283
if (repository_policy is not None and
1284
repository_policy.requires_stacking()):
1285
to_bzrdir._format.require_stacking(_skip_repo=True)
1286
result = to_bzrdir.create_branch(repository=repository)
1289
if repository_policy is not None:
1290
repository_policy.configure_branch(result)
1291
self.copy_content_into(result, revision_id=revision_id)
1292
master_url = self.get_bound_location()
1293
if master_url is None:
1294
result.set_parent(self.bzrdir.root_transport.base)
1296
result.set_parent(master_url)
693
1301
def _synchronize_history(self, destination, revision_id):
694
1302
"""Synchronize last revision and revision history between branches.
696
1304
This version is most efficient when the destination is also a
697
BzrBranch5, but works for BzrBranch6 as long as the revision
698
history is the true lefthand parent history, and all of the revisions
699
are in the destination's repository. If not, set_revision_history
1305
BzrBranch6, but works for BzrBranch5, as long as the destination's
1306
repository contains all the lefthand ancestors of the intended
1307
last_revision. If not, set_last_revision_info will fail.
702
1309
:param destination: The branch to copy the history into
703
1310
:param revision_id: The revision-id to truncate history at. May
704
1311
be None to copy complete history.
706
if revision_id == _mod_revision.NULL_REVISION:
1313
source_revno, source_revision_id = self.last_revision_info()
1314
if revision_id is None:
1315
revno, revision_id = source_revno, source_revision_id
709
new_history = self.revision_history()
710
if revision_id is not None and new_history != []:
1317
graph = self.repository.get_graph()
712
new_history = new_history[:new_history.index(revision_id) + 1]
714
rev = self.repository.get_revision(revision_id)
715
new_history = rev.get_history(self.repository)[1:]
716
destination.set_revision_history(new_history)
1319
revno = graph.find_distance_to_null(revision_id,
1320
[(source_revision_id, source_revno)])
1321
except errors.GhostRevisionsHaveNoRevno:
1322
# Default to 1, if we can't find anything else
1324
destination.set_last_revision_info(revno, revision_id)
719
1326
def copy_content_into(self, destination, revision_id=None):
720
1327
"""Copy the content of self into destination.
722
1329
revision_id: if not None, the revision history in the new branch will
723
1330
be truncated to end with revision_id.
725
self._synchronize_history(destination, revision_id)
727
parent = self.get_parent()
728
except errors.InaccessibleParent, e:
729
mutter('parent was not accessible to copy: %s', e)
732
destination.set_parent(parent)
733
self.tags.merge_to(destination.tags)
1332
return InterBranch.get(self, destination).copy_content_into(
1333
revision_id=revision_id)
1335
def update_references(self, target):
1336
if not getattr(self._format, 'supports_reference_locations', False):
1338
reference_dict = self._get_all_reference_info()
1339
if len(reference_dict) == 0:
1341
old_base = self.base
1342
new_base = target.base
1343
target_reference_dict = target._get_all_reference_info()
1344
for file_id, (tree_path, branch_location) in (
1345
reference_dict.items()):
1346
branch_location = urlutils.rebase_url(branch_location,
1348
target_reference_dict.setdefault(
1349
file_id, (tree_path, branch_location))
1350
target._set_all_reference_info(target_reference_dict)
735
1352
@needs_read_lock
1353
def check(self, refs):
737
1354
"""Check consistency of the branch.
739
1356
In particular this checks that revisions given in the revision-history
740
do actually match up in the revision graph, and that they're all
1357
do actually match up in the revision graph, and that they're all
741
1358
present in the repository.
743
1360
Callers will typically also want to check the repository.
1362
:param refs: Calculated refs for this branch as specified by
1363
branch._get_check_refs()
745
1364
:return: A BranchCheckResult.
747
mainline_parent_id = None
1366
result = BranchCheckResult(self)
748
1367
last_revno, last_revision_id = self.last_revision_info()
749
real_rev_history = list(self.repository.iter_reverse_revision_history(
751
real_rev_history.reverse()
752
if len(real_rev_history) != last_revno:
753
raise errors.BzrCheckError('revno does not match len(mainline)'
754
' %s != %s' % (last_revno, len(real_rev_history)))
755
# TODO: We should probably also check that real_rev_history actually
756
# matches self.revision_history()
757
for revision_id in real_rev_history:
759
revision = self.repository.get_revision(revision_id)
760
except errors.NoSuchRevision, e:
761
raise errors.BzrCheckError("mainline revision {%s} not in repository"
763
# In general the first entry on the revision history has no parents.
764
# But it's not illegal for it to have parents listed; this can happen
765
# in imports from Arch when the parents weren't reachable.
766
if mainline_parent_id is not None:
767
if mainline_parent_id not in revision.parent_ids:
768
raise errors.BzrCheckError("previous revision {%s} not listed among "
770
% (mainline_parent_id, revision_id))
771
mainline_parent_id = revision_id
772
return BranchCheckResult(self)
1368
actual_revno = refs[('lefthand-distance', last_revision_id)]
1369
if actual_revno != last_revno:
1370
result.errors.append(errors.BzrCheckError(
1371
'revno does not match len(mainline) %s != %s' % (
1372
last_revno, actual_revno)))
1373
# TODO: We should probably also check that self.revision_history
1374
# matches the repository for older branch formats.
1375
# If looking for the code that cross-checks repository parents against
1376
# the iter_reverse_revision_history output, that is now a repository
774
1380
def _get_checkout_format(self):
775
1381
"""Return the most suitable metadir for a checkout of this branch.
776
1382
Weaves are used if this branch's repository uses weaves.
778
if isinstance(self.bzrdir, bzrdir.BzrDirPreSplitOut):
779
from bzrlib.repofmt import weaverepo
780
format = bzrdir.BzrDirMetaFormat1()
781
format.repository_format = weaverepo.RepositoryFormat7()
783
format = self.repository.bzrdir.checkout_metadir()
784
format.set_branch_format(self._format)
1384
format = self.repository.bzrdir.checkout_metadir()
1385
format.set_branch_format(self._format)
1388
def create_clone_on_transport(self, to_transport, revision_id=None,
1389
stacked_on=None, create_prefix=False, use_existing_dir=False,
1391
"""Create a clone of this branch and its bzrdir.
1393
:param to_transport: The transport to clone onto.
1394
:param revision_id: The revision id to use as tip in the new branch.
1395
If None the tip is obtained from this branch.
1396
:param stacked_on: An optional URL to stack the clone on.
1397
:param create_prefix: Create any missing directories leading up to
1399
:param use_existing_dir: Use an existing directory if one exists.
1401
# XXX: Fix the bzrdir API to allow getting the branch back from the
1402
# clone call. Or something. 20090224 RBC/spiv.
1403
# XXX: Should this perhaps clone colocated branches as well,
1404
# rather than just the default branch? 20100319 JRV
1405
if revision_id is None:
1406
revision_id = self.last_revision()
1407
dir_to = self.bzrdir.clone_on_transport(to_transport,
1408
revision_id=revision_id, stacked_on=stacked_on,
1409
create_prefix=create_prefix, use_existing_dir=use_existing_dir,
1411
return dir_to.open_branch()
787
1413
def create_checkout(self, to_location, revision_id=None,
788
1414
lightweight=False, accelerator_tree=None,
789
1415
hardlink=False):
790
1416
"""Create a checkout of a branch.
792
1418
:param to_location: The url to produce the checkout at
793
1419
:param revision_id: The revision to check out
794
1420
:param lightweight: If True, produce a lightweight checkout, otherwise,
795
produce a bound branch (heavyweight checkout)
1421
produce a bound branch (heavyweight checkout)
796
1422
:param accelerator_tree: A tree which can be used for retrieving file
797
1423
contents more quickly than the revision tree, i.e. a workingtree.
798
1424
The revision tree will be used for cases where accelerator_tree's
969
1644
"""Return the short format description for this format."""
970
1645
raise NotImplementedError(self.get_format_description)
972
def _initialize_helper(self, a_bzrdir, utf8_files, lock_type='metadir',
974
"""Initialize a branch in a bzrdir, with specified files
1647
def _run_post_branch_init_hooks(self, a_bzrdir, name, branch):
1648
hooks = Branch.hooks['post_branch_init']
1651
params = BranchInitHookParams(self, a_bzrdir, name, branch)
976
:param a_bzrdir: The bzrdir to initialize the branch in
977
:param utf8_files: The files to create as a list of
978
(filename, content) tuples
979
:param set_format: If True, set the format with
980
self.get_format_string. (BzrBranch4 has its format set
982
:return: a branch in this format
1655
def initialize(self, a_bzrdir, name=None, repository=None):
1656
"""Create a branch of this format in a_bzrdir.
1658
:param name: Name of the colocated branch to create.
984
mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
985
branch_transport = a_bzrdir.get_branch_transport(self)
987
'metadir': ('lock', lockdir.LockDir),
988
'branch4': ('branch-lock', lockable_files.TransportLock),
990
lock_name, lock_class = lock_map[lock_type]
991
control_files = lockable_files.LockableFiles(branch_transport,
992
lock_name, lock_class)
993
control_files.create_lock()
994
control_files.lock_write()
996
utf8_files += [('format', self.get_format_string())]
998
for (filename, content) in utf8_files:
999
branch_transport.put_bytes(
1001
mode=a_bzrdir._get_file_mode())
1003
control_files.unlock()
1004
return self.open(a_bzrdir, _found=True)
1006
def initialize(self, a_bzrdir):
1007
"""Create a branch of this format in a_bzrdir."""
1008
1660
raise NotImplementedError(self.initialize)
1010
1662
def is_supported(self):
1011
1663
"""Is this format supported?
1013
1665
Supported formats can be initialized and opened.
1014
Unsupported formats may not support initialization or committing or
1666
Unsupported formats may not support initialization or committing or
1015
1667
some other features depending on the reason for not being supported.
1019
def open(self, a_bzrdir, _found=False):
1671
def make_tags(self, branch):
1672
"""Create a tags object for branch.
1674
This method is on BranchFormat, because BranchFormats are reflected
1675
over the wire via network_name(), whereas full Branch instances require
1676
multiple VFS method calls to operate at all.
1678
The default implementation returns a disabled-tags instance.
1680
Note that it is normal for branch to be a RemoteBranch when using tags
1683
return DisabledTags(branch)
1685
def network_name(self):
1686
"""A simple byte string uniquely identifying this format for RPC calls.
1688
MetaDir branch formats use their disk format string to identify the
1689
repository over the wire. All in one formats such as bzr < 0.8, and
1690
foreign formats like svn/git and hg should use some marker which is
1691
unique and immutable.
1693
raise NotImplementedError(self.network_name)
1695
def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False,
1696
found_repository=None):
1020
1697
"""Return the branch object for a_bzrdir
1022
_found is a private parameter, do not use it. It is used to indicate
1023
if format probing has already be done.
1699
:param a_bzrdir: A BzrDir that contains a branch.
1700
:param name: Name of colocated branch to open
1701
:param _found: a private parameter, do not use it. It is used to
1702
indicate if format probing has already be done.
1703
:param ignore_fallbacks: when set, no fallback branches will be opened
1704
(if there are any). Default is to open fallbacks.
1025
1706
raise NotImplementedError(self.open)
1709
@deprecated_method(deprecated_in((2, 4, 0)))
1028
1710
def register_format(klass, format):
1029
klass._formats[format.get_format_string()] = format
1711
"""Register a metadir format.
1713
See MetaDirBranchFormatFactory for the ability to register a format
1714
without loading the code the format needs until it is actually used.
1716
format_registry.register(format)
1719
@deprecated_method(deprecated_in((2, 4, 0)))
1032
1720
def set_default_format(klass, format):
1033
klass._default_format = format
1721
format_registry.set_default(format)
1723
def supports_set_append_revisions_only(self):
1724
"""True if this format supports set_append_revisions_only."""
1035
1727
def supports_stacking(self):
1036
1728
"""True if this format records a stacked-on branch."""
1731
def supports_leaving_lock(self):
1732
"""True if this format supports leaving locks in place."""
1733
return False # by default
1736
@deprecated_method(deprecated_in((2, 4, 0)))
1040
1737
def unregister_format(klass, format):
1041
del klass._formats[format.get_format_string()]
1738
format_registry.remove(format)
1043
1740
def __str__(self):
1044
return self.get_format_string().rstrip()
1741
return self.get_format_description().rstrip()
1046
1743
def supports_tags(self):
1047
1744
"""True if this format supports tags stored in the branch"""
1048
1745
return False # by default
1748
class MetaDirBranchFormatFactory(registry._LazyObjectGetter):
1749
"""A factory for a BranchFormat object, permitting simple lazy registration.
1751
While none of the built in BranchFormats are lazy registered yet,
1752
bzrlib.tests.test_branch.TestMetaDirBranchFormatFactory demonstrates how to
1753
use it, and the bzr-loom plugin uses it as well (see
1754
bzrlib.plugins.loom.formats).
1757
def __init__(self, format_string, module_name, member_name):
1758
"""Create a MetaDirBranchFormatFactory.
1760
:param format_string: The format string the format has.
1761
:param module_name: Module to load the format class from.
1762
:param member_name: Attribute name within the module for the format class.
1764
registry._LazyObjectGetter.__init__(self, module_name, member_name)
1765
self._format_string = format_string
1767
def get_format_string(self):
1768
"""See BranchFormat.get_format_string."""
1769
return self._format_string
1772
"""Used for network_format_registry support."""
1773
return self.get_obj()()
1051
1776
class BranchHooks(Hooks):
1052
1777
"""A dictionary mapping hook name to a list of callables for branch hooks.
1054
1779
e.g. ['set_rh'] Is the list of items to be called when the
1055
1780
set_revision_history function is invoked.
1061
1786
These are all empty initially, because by default nothing should get
1064
Hooks.__init__(self)
1065
# Introduced in 0.15:
1066
# invoked whenever the revision history has been set
1067
# with set_revision_history. The api signature is
1068
# (branch, revision_history), and the branch will
1071
# invoked after a push operation completes.
1072
# the api signature is
1074
# containing the members
1075
# (source, local, master, old_revno, old_revid, new_revno, new_revid)
1076
# where local is the local target branch or None, master is the target
1077
# master branch, and the rest should be self explanatory. The source
1078
# is read locked and the target branches write locked. Source will
1079
# be the local low-latency branch.
1080
self['post_push'] = []
1081
# invoked after a pull operation completes.
1082
# the api signature is
1084
# containing the members
1085
# (source, local, master, old_revno, old_revid, new_revno, new_revid)
1086
# where local is the local branch or None, master is the target
1087
# master branch, and the rest should be self explanatory. The source
1088
# is read locked and the target branches write locked. The local
1089
# branch is the low-latency branch.
1090
self['post_pull'] = []
1091
# invoked before a commit operation takes place.
1092
# the api signature is
1093
# (local, master, old_revno, old_revid, future_revno, future_revid,
1094
# tree_delta, future_tree).
1095
# old_revid is NULL_REVISION for the first commit to a branch
1096
# tree_delta is a TreeDelta object describing changes from the basis
1097
# revision, hooks MUST NOT modify this delta
1098
# future_tree is an in-memory tree obtained from
1099
# CommitBuilder.revision_tree() and hooks MUST NOT modify this tree
1100
self['pre_commit'] = []
1101
# invoked after a commit operation completes.
1102
# the api signature is
1103
# (local, master, old_revno, old_revid, new_revno, new_revid)
1104
# old_revid is NULL_REVISION for the first commit to a branch.
1105
self['post_commit'] = []
1106
# invoked after a uncommit operation completes.
1107
# the api signature is
1108
# (local, master, old_revno, old_revid, new_revno, new_revid) where
1109
# local is the local branch or None, master is the target branch,
1110
# and an empty branch recieves new_revno of 0, new_revid of None.
1111
self['post_uncommit'] = []
1113
# Invoked before the tip of a branch changes.
1114
# the api signature is
1115
# (params) where params is a ChangeBranchTipParams with the members
1116
# (branch, old_revno, new_revno, old_revid, new_revid)
1117
self['pre_change_branch_tip'] = []
1119
# Invoked after the tip of a branch changes.
1120
# the api signature is
1121
# (params) where params is a ChangeBranchTipParams with the members
1122
# (branch, old_revno, new_revno, old_revid, new_revid)
1123
self['post_change_branch_tip'] = []
1789
Hooks.__init__(self, "bzrlib.branch", "Branch.hooks")
1790
self.add_hook('set_rh',
1791
"Invoked whenever the revision history has been set via "
1792
"set_revision_history. The api signature is (branch, "
1793
"revision_history), and the branch will be write-locked. "
1794
"The set_rh hook can be expensive for bzr to trigger, a better "
1795
"hook to use is Branch.post_change_branch_tip.", (0, 15))
1796
self.add_hook('open',
1797
"Called with the Branch object that has been opened after a "
1798
"branch is opened.", (1, 8))
1799
self.add_hook('post_push',
1800
"Called after a push operation completes. post_push is called "
1801
"with a bzrlib.branch.BranchPushResult object and only runs in the "
1802
"bzr client.", (0, 15))
1803
self.add_hook('post_pull',
1804
"Called after a pull operation completes. post_pull is called "
1805
"with a bzrlib.branch.PullResult object and only runs in the "
1806
"bzr client.", (0, 15))
1807
self.add_hook('pre_commit',
1808
"Called after a commit is calculated but before it is "
1809
"completed. pre_commit is called with (local, master, old_revno, "
1810
"old_revid, future_revno, future_revid, tree_delta, future_tree"
1811
"). old_revid is NULL_REVISION for the first commit to a branch, "
1812
"tree_delta is a TreeDelta object describing changes from the "
1813
"basis revision. hooks MUST NOT modify this delta. "
1814
" future_tree is an in-memory tree obtained from "
1815
"CommitBuilder.revision_tree() and hooks MUST NOT modify this "
1817
self.add_hook('post_commit',
1818
"Called in the bzr client after a commit has completed. "
1819
"post_commit is called with (local, master, old_revno, old_revid, "
1820
"new_revno, new_revid). old_revid is NULL_REVISION for the first "
1821
"commit to a branch.", (0, 15))
1822
self.add_hook('post_uncommit',
1823
"Called in the bzr client after an uncommit completes. "
1824
"post_uncommit is called with (local, master, old_revno, "
1825
"old_revid, new_revno, new_revid) where local is the local branch "
1826
"or None, master is the target branch, and an empty branch "
1827
"receives new_revno of 0, new_revid of None.", (0, 15))
1828
self.add_hook('pre_change_branch_tip',
1829
"Called in bzr client and server before a change to the tip of a "
1830
"branch is made. pre_change_branch_tip is called with a "
1831
"bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1832
"commit, uncommit will all trigger this hook.", (1, 6))
1833
self.add_hook('post_change_branch_tip',
1834
"Called in bzr client and server after a change to the tip of a "
1835
"branch is made. post_change_branch_tip is called with a "
1836
"bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1837
"commit, uncommit will all trigger this hook.", (1, 4))
1838
self.add_hook('transform_fallback_location',
1839
"Called when a stacked branch is activating its fallback "
1840
"locations. transform_fallback_location is called with (branch, "
1841
"url), and should return a new url. Returning the same url "
1842
"allows it to be used as-is, returning a different one can be "
1843
"used to cause the branch to stack on a closer copy of that "
1844
"fallback_location. Note that the branch cannot have history "
1845
"accessing methods called on it during this hook because the "
1846
"fallback locations have not been activated. When there are "
1847
"multiple hooks installed for transform_fallback_location, "
1848
"all are called with the url returned from the previous hook."
1849
"The order is however undefined.", (1, 9))
1850
self.add_hook('automatic_tag_name',
1851
"Called to determine an automatic tag name for a revision. "
1852
"automatic_tag_name is called with (branch, revision_id) and "
1853
"should return a tag name or None if no tag name could be "
1854
"determined. The first non-None tag name returned will be used.",
1856
self.add_hook('post_branch_init',
1857
"Called after new branch initialization completes. "
1858
"post_branch_init is called with a "
1859
"bzrlib.branch.BranchInitHookParams. "
1860
"Note that init, branch and checkout (both heavyweight and "
1861
"lightweight) will all trigger this hook.", (2, 2))
1862
self.add_hook('post_switch',
1863
"Called after a checkout switches branch. "
1864
"post_switch is called with a "
1865
"bzrlib.branch.SwitchHookParams.", (2, 2))
1126
1869
# install the default hooks into the Branch class.
1159
1902
def __eq__(self, other):
1160
1903
return self.__dict__ == other.__dict__
1162
1905
def __repr__(self):
1163
1906
return "<%s of %s from (%s, %s) to (%s, %s)>" % (
1164
self.__class__.__name__, self.branch,
1907
self.__class__.__name__, self.branch,
1165
1908
self.old_revno, self.old_revid, self.new_revno, self.new_revid)
1168
class BzrBranchFormat4(BranchFormat):
1169
"""Bzr branch format 4.
1172
- a revision-history file.
1173
- a branch-lock lock file [ to be shared with the bzrdir ]
1176
def get_format_description(self):
1177
"""See BranchFormat.get_format_description()."""
1178
return "Branch format 4"
1180
def initialize(self, a_bzrdir):
1181
"""Create a branch of this format in a_bzrdir."""
1182
utf8_files = [('revision-history', ''),
1183
('branch-name', ''),
1185
return self._initialize_helper(a_bzrdir, utf8_files,
1186
lock_type='branch4', set_format=False)
1189
super(BzrBranchFormat4, self).__init__()
1190
self._matchingbzrdir = bzrdir.BzrDirFormat6()
1192
def open(self, a_bzrdir, _found=False):
1193
"""Return the branch object for a_bzrdir
1195
_found is a private parameter, do not use it. It is used to indicate
1196
if format probing has already be done.
1199
# we are being called directly and must probe.
1200
raise NotImplementedError
1201
return BzrBranch(_format=self,
1202
_control_files=a_bzrdir._control_files,
1204
_repository=a_bzrdir.open_repository())
1207
return "Bazaar-NG branch format 4"
1911
class BranchInitHookParams(object):
1912
"""Object holding parameters passed to `*_branch_init` hooks.
1914
There are 4 fields that hooks may wish to access:
1916
:ivar format: the branch format
1917
:ivar bzrdir: the BzrDir where the branch will be/has been initialized
1918
:ivar name: name of colocated branch, if any (or None)
1919
:ivar branch: the branch created
1921
Note that for lightweight checkouts, the bzrdir and format fields refer to
1922
the checkout, hence they are different from the corresponding fields in
1923
branch, which refer to the original branch.
1926
def __init__(self, format, a_bzrdir, name, branch):
1927
"""Create a group of BranchInitHook parameters.
1929
:param format: the branch format
1930
:param a_bzrdir: the BzrDir where the branch will be/has been
1932
:param name: name of colocated branch, if any (or None)
1933
:param branch: the branch created
1935
Note that for lightweight checkouts, the bzrdir and format fields refer
1936
to the checkout, hence they are different from the corresponding fields
1937
in branch, which refer to the original branch.
1939
self.format = format
1940
self.bzrdir = a_bzrdir
1942
self.branch = branch
1944
def __eq__(self, other):
1945
return self.__dict__ == other.__dict__
1948
return "<%s of %s>" % (self.__class__.__name__, self.branch)
1951
class SwitchHookParams(object):
1952
"""Object holding parameters passed to `*_switch` hooks.
1954
There are 4 fields that hooks may wish to access:
1956
:ivar control_dir: BzrDir of the checkout to change
1957
:ivar to_branch: branch that the checkout is to reference
1958
:ivar force: skip the check for local commits in a heavy checkout
1959
:ivar revision_id: revision ID to switch to (or None)
1962
def __init__(self, control_dir, to_branch, force, revision_id):
1963
"""Create a group of SwitchHook parameters.
1965
:param control_dir: BzrDir of the checkout to change
1966
:param to_branch: branch that the checkout is to reference
1967
:param force: skip the check for local commits in a heavy checkout
1968
:param revision_id: revision ID to switch to (or None)
1970
self.control_dir = control_dir
1971
self.to_branch = to_branch
1973
self.revision_id = revision_id
1975
def __eq__(self, other):
1976
return self.__dict__ == other.__dict__
1979
return "<%s for %s to (%s, %s)>" % (self.__class__.__name__,
1980
self.control_dir, self.to_branch,
1210
1984
class BranchFormatMetadir(BranchFormat):
1214
1988
"""What class to instantiate on open calls."""
1215
1989
raise NotImplementedError(self._branch_class)
1217
def open(self, a_bzrdir, _found=False):
1218
"""Return the branch object for a_bzrdir.
1220
_found is a private parameter, do not use it. It is used to indicate
1221
if format probing has already be done.
1991
def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
1993
"""Initialize a branch in a bzrdir, with specified files
1995
:param a_bzrdir: The bzrdir to initialize the branch in
1996
:param utf8_files: The files to create as a list of
1997
(filename, content) tuples
1998
:param name: Name of colocated branch to create, if any
1999
:return: a branch in this format
2001
mutter('creating branch %r in %s', self, a_bzrdir.user_url)
2002
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
2003
control_files = lockable_files.LockableFiles(branch_transport,
2004
'lock', lockdir.LockDir)
2005
control_files.create_lock()
2006
control_files.lock_write()
2008
utf8_files += [('format', self.get_format_string())]
2009
for (filename, content) in utf8_files:
2010
branch_transport.put_bytes(
2012
mode=a_bzrdir._get_file_mode())
2014
control_files.unlock()
2015
branch = self.open(a_bzrdir, name, _found=True,
2016
found_repository=repository)
2017
self._run_post_branch_init_hooks(a_bzrdir, name, branch)
2020
def network_name(self):
2021
"""A simple byte string uniquely identifying this format for RPC calls.
2023
Metadir branch formats use their format string.
2025
return self.get_format_string()
2027
def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False,
2028
found_repository=None):
2029
"""See BranchFormat.open()."""
1224
format = BranchFormat.find_format(a_bzrdir)
2031
format = BranchFormat.find_format(a_bzrdir, name=name)
1225
2032
if format.__class__ != self.__class__:
1226
2033
raise AssertionError("wrong format %r found for %r" %
1227
2034
(format, self))
2035
transport = a_bzrdir.get_branch_transport(None, name=name)
1229
transport = a_bzrdir.get_branch_transport(None)
1230
2037
control_files = lockable_files.LockableFiles(transport, 'lock',
1231
2038
lockdir.LockDir)
2039
if found_repository is None:
2040
found_repository = a_bzrdir.find_repository()
1232
2041
return self._branch_class()(_format=self,
1233
2042
_control_files=control_files,
1234
2044
a_bzrdir=a_bzrdir,
1235
_repository=a_bzrdir.find_repository())
2045
_repository=found_repository,
2046
ignore_fallbacks=ignore_fallbacks)
1236
2047
except errors.NoSuchFile:
1237
raise errors.NotBranchError(path=transport.base)
2048
raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1239
2050
def __init__(self):
1240
2051
super(BranchFormatMetadir, self).__init__()
1241
2052
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
2053
self._matchingbzrdir.set_branch_format(self)
1243
2055
def supports_tags(self):
2058
def supports_leaving_lock(self):
1247
2062
class BzrBranchFormat5(BranchFormatMetadir):
1248
2063
"""Bzr branch format 5.
1366
2228
"""See BranchFormat.get_format_description()."""
1367
2229
return "Checkout reference format 1"
1369
def get_reference(self, a_bzrdir):
2231
def get_reference(self, a_bzrdir, name=None):
1370
2232
"""See BranchFormat.get_reference()."""
1371
transport = a_bzrdir.get_branch_transport(None)
1372
return transport.get('location').read()
2233
transport = a_bzrdir.get_branch_transport(None, name=name)
2234
return transport.get_bytes('location')
1374
def set_reference(self, a_bzrdir, to_branch):
2236
def set_reference(self, a_bzrdir, name, to_branch):
1375
2237
"""See BranchFormat.set_reference()."""
1376
transport = a_bzrdir.get_branch_transport(None)
2238
transport = a_bzrdir.get_branch_transport(None, name=name)
1377
2239
location = transport.put_bytes('location', to_branch.base)
1379
def initialize(self, a_bzrdir, target_branch=None):
2241
def initialize(self, a_bzrdir, name=None, target_branch=None,
1380
2243
"""Create a branch of this format in a_bzrdir."""
1381
2244
if target_branch is None:
1382
2245
# this format does not implement branch itself, thus the implicit
1383
2246
# creation contract must see it as uninitializable
1384
2247
raise errors.UninitializableFormat(self)
1385
mutter('creating branch reference in %s', a_bzrdir.transport.base)
1386
branch_transport = a_bzrdir.get_branch_transport(self)
2248
mutter('creating branch reference in %s', a_bzrdir.user_url)
2249
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1387
2250
branch_transport.put_bytes('location',
1388
target_branch.bzrdir.root_transport.base)
2251
target_branch.bzrdir.user_url)
1389
2252
branch_transport.put_bytes('format', self.get_format_string())
1391
a_bzrdir, _found=True,
2254
a_bzrdir, name, _found=True,
1392
2255
possible_transports=[target_branch.bzrdir.root_transport])
2256
self._run_post_branch_init_hooks(a_bzrdir, name, branch)
1394
2259
def __init__(self):
1395
2260
super(BranchReferenceFormat, self).__init__()
1396
2261
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
2262
self._matchingbzrdir.set_branch_format(self)
1398
2264
def _make_reference_clone_function(format, a_branch):
1399
2265
"""Create a clone() routine for a branch dynamically."""
1400
def clone(to_bzrdir, revision_id=None):
2266
def clone(to_bzrdir, revision_id=None,
2267
repository_policy=None):
1401
2268
"""See Branch.clone()."""
1402
return format.initialize(to_bzrdir, a_branch)
2269
return format.initialize(to_bzrdir, target_branch=a_branch)
1403
2270
# cannot obey revision_id limits when cloning a reference ...
1404
2271
# FIXME RBC 20060210 either nuke revision_id for clone, or
1405
2272
# emit some sort of warning/error to the caller ?!
1408
def open(self, a_bzrdir, _found=False, location=None,
1409
possible_transports=None):
2275
def open(self, a_bzrdir, name=None, _found=False, location=None,
2276
possible_transports=None, ignore_fallbacks=False,
2277
found_repository=None):
1410
2278
"""Return the branch that the branch reference in a_bzrdir points at.
1412
_found is a private parameter, do not use it. It is used to indicate
1413
if format probing has already be done.
2280
:param a_bzrdir: A BzrDir that contains a branch.
2281
:param name: Name of colocated branch to open, if any
2282
:param _found: a private parameter, do not use it. It is used to
2283
indicate if format probing has already be done.
2284
:param ignore_fallbacks: when set, no fallback branches will be opened
2285
(if there are any). Default is to open fallbacks.
2286
:param location: The location of the referenced branch. If
2287
unspecified, this will be determined from the branch reference in
2289
:param possible_transports: An optional reusable transports list.
1416
format = BranchFormat.find_format(a_bzrdir)
2292
format = BranchFormat.find_format(a_bzrdir, name=name)
1417
2293
if format.__class__ != self.__class__:
1418
2294
raise AssertionError("wrong format %r found for %r" %
1419
2295
(format, self))
1420
2296
if location is None:
1421
location = self.get_reference(a_bzrdir)
2297
location = self.get_reference(a_bzrdir, name)
1422
2298
real_bzrdir = bzrdir.BzrDir.open(
1423
2299
location, possible_transports=possible_transports)
1424
result = real_bzrdir.open_branch()
2300
result = real_bzrdir.open_branch(name=name,
2301
ignore_fallbacks=ignore_fallbacks)
1425
2302
# this changes the behaviour of result.clone to create a new reference
1426
2303
# rather than a copy of the content of the branch.
1427
2304
# I did not use a proxy object because that needs much more extensive
2314
class BranchFormatRegistry(controldir.ControlComponentFormatRegistry):
2315
"""Branch format registry."""
2317
def __init__(self, other_registry=None):
2318
super(BranchFormatRegistry, self).__init__(other_registry)
2319
self._default_format = None
2321
def set_default(self, format):
2322
self._default_format = format
2324
def get_default(self):
2325
return self._default_format
2328
network_format_registry = registry.FormatRegistry()
2329
"""Registry of formats indexed by their network name.
2331
The network name for a branch format is an identifier that can be used when
2332
referring to formats with smart server operations. See
2333
BranchFormat.network_name() for more detail.
2336
format_registry = BranchFormatRegistry(network_format_registry)
1437
2339
# formats which have no format string are not discoverable
1438
2340
# and not independently creatable, so are not registered.
1439
2341
__format5 = BzrBranchFormat5()
1440
2342
__format6 = BzrBranchFormat6()
1441
2343
__format7 = BzrBranchFormat7()
1442
BranchFormat.register_format(__format5)
1443
BranchFormat.register_format(BranchReferenceFormat())
1444
BranchFormat.register_format(__format6)
1445
BranchFormat.register_format(__format7)
1446
BranchFormat.set_default_format(__format6)
1447
_legacy_formats = [BzrBranchFormat4(),
1450
class BzrBranch(Branch):
2344
__format8 = BzrBranchFormat8()
2345
format_registry.register(__format5)
2346
format_registry.register(BranchReferenceFormat())
2347
format_registry.register(__format6)
2348
format_registry.register(__format7)
2349
format_registry.register(__format8)
2350
format_registry.set_default(__format7)
2353
class BranchWriteLockResult(LogicalLockResult):
2354
"""The result of write locking a branch.
2356
:ivar branch_token: The token obtained from the underlying branch lock, or
2358
:ivar unlock: A callable which will unlock the lock.
2361
def __init__(self, unlock, branch_token):
2362
LogicalLockResult.__init__(self, unlock)
2363
self.branch_token = branch_token
2366
return "BranchWriteLockResult(%s, %s)" % (self.branch_token,
2370
class BzrBranch(Branch, _RelockDebugMixin):
1451
2371
"""A branch stored in the actual filesystem.
1453
2373
Note that it's "local" in the context of the filesystem; it doesn't
1454
2374
really matter if it's on an nfs/smb/afs/coda/... share, as long as
1455
2375
it's writable, and can be accessed via the normal filesystem API.
1457
:ivar _transport: Transport for file operations on this branch's
2377
:ivar _transport: Transport for file operations on this branch's
1458
2378
control files, typically pointing to the .bzr/branch directory.
1459
2379
:ivar repository: Repository for this branch.
1460
:ivar base: The url of the base directory for this branch; the one
2380
:ivar base: The url of the base directory for this branch; the one
1461
2381
containing the .bzr directory.
2382
:ivar name: Optional colocated branch name as it exists in the control
1464
2386
def __init__(self, _format=None,
1465
_control_files=None, a_bzrdir=None, _repository=None):
2387
_control_files=None, a_bzrdir=None, name=None,
2388
_repository=None, ignore_fallbacks=False):
1466
2389
"""Create new branch object at a particular location."""
1467
2390
if a_bzrdir is None:
1468
2391
raise ValueError('a_bzrdir must be supplied')
1470
2393
self.bzrdir = a_bzrdir
1471
2394
self._base = self.bzrdir.transport.clone('..').base
1472
2396
# XXX: We should be able to just do
1473
2397
# self.base = self.bzrdir.root_transport.base
1474
2398
# but this does not quite work yet -- mbp 20080522
1535
2501
"""See Branch.print_file."""
1536
2502
return self.repository.print_file(file, revision_id)
1538
def _write_revision_history(self, history):
1539
"""Factored out of set_revision_history.
1541
This performs the actual writing to disk.
1542
It is intended to be called by BzrBranch5.set_revision_history."""
1543
self._transport.put_bytes(
1544
'revision-history', '\n'.join(history),
1545
mode=self.bzrdir._get_file_mode())
1548
def set_revision_history(self, rev_history):
1549
"""See Branch.set_revision_history."""
1550
if 'evil' in debug.debug_flags:
1551
mutter_callsite(3, "set_revision_history scales with history.")
1552
check_not_reserved_id = _mod_revision.check_not_reserved_id
1553
for rev_id in rev_history:
1554
check_not_reserved_id(rev_id)
1555
if Branch.hooks['post_change_branch_tip']:
1556
# Don't calculate the last_revision_info() if there are no hooks
1558
old_revno, old_revid = self.last_revision_info()
1559
if len(rev_history) == 0:
1560
revid = _mod_revision.NULL_REVISION
1562
revid = rev_history[-1]
1563
self._run_pre_change_branch_tip_hooks(len(rev_history), revid)
1564
self._write_revision_history(rev_history)
1565
self._clear_cached_state()
1566
self._cache_revision_history(rev_history)
1567
for hook in Branch.hooks['set_rh']:
1568
hook(self, rev_history)
1569
if Branch.hooks['post_change_branch_tip']:
1570
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
1572
def _run_pre_change_branch_tip_hooks(self, new_revno, new_revid):
1573
"""Run the pre_change_branch_tip hooks."""
1574
hooks = Branch.hooks['pre_change_branch_tip']
1577
old_revno, old_revid = self.last_revision_info()
1578
params = ChangeBranchTipParams(
1579
self, old_revno, new_revno, old_revid, new_revid)
1583
except errors.TipChangeRejected:
1586
exc_info = sys.exc_info()
1587
hook_name = Branch.hooks.get_hook_name(hook)
1588
raise errors.HookFailed(
1589
'pre_change_branch_tip', hook_name, exc_info)
1591
def _run_post_change_branch_tip_hooks(self, old_revno, old_revid):
1592
"""Run the post_change_branch_tip hooks."""
1593
hooks = Branch.hooks['post_change_branch_tip']
1596
new_revno, new_revid = self.last_revision_info()
1597
params = ChangeBranchTipParams(
1598
self, old_revno, new_revno, old_revid, new_revid)
1602
2504
@needs_write_lock
1603
2505
def set_last_revision_info(self, revno, revision_id):
1604
"""Set the last revision of this branch.
1606
The caller is responsible for checking that the revno is correct
1607
for this revision id.
1609
It may be possible to set the branch last revision to an id not
1610
present in the repository. However, branches can also be
1611
configured to check constraints on history, in which case this may not
2506
if not revision_id or not isinstance(revision_id, basestring):
2507
raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
1614
2508
revision_id = _mod_revision.ensure_null(revision_id)
1615
# this old format stores the full history, but this api doesn't
1616
# provide it, so we must generate, and might as well check it's
1618
history = self._lefthand_history(revision_id)
1619
if len(history) != revno:
1620
raise AssertionError('%d != %d' % (len(history), revno))
1621
self.set_revision_history(history)
1623
def _gen_revision_history(self):
1624
history = self._transport.get_bytes('revision-history').split('\n')
1625
if history[-1:] == ['']:
1626
# There shouldn't be a trailing newline, but just in case.
1630
def _lefthand_history(self, revision_id, last_rev=None,
1632
if 'evil' in debug.debug_flags:
1633
mutter_callsite(4, "_lefthand_history scales with history.")
1634
# stop_revision must be a descendant of last_revision
1635
graph = self.repository.get_graph()
1636
if last_rev is not None:
1637
if not graph.is_ancestor(last_rev, revision_id):
1638
# our previous tip is not merged into stop_revision
1639
raise errors.DivergedBranches(self, other_branch)
1640
# make a new revision history from the graph
1641
parents_map = graph.get_parent_map([revision_id])
1642
if revision_id not in parents_map:
1643
raise errors.NoSuchRevision(self, revision_id)
1644
current_rev_id = revision_id
1646
check_not_reserved_id = _mod_revision.check_not_reserved_id
1647
# Do not include ghosts or graph origin in revision_history
1648
while (current_rev_id in parents_map and
1649
len(parents_map[current_rev_id]) > 0):
1650
check_not_reserved_id(current_rev_id)
1651
new_history.append(current_rev_id)
1652
current_rev_id = parents_map[current_rev_id][0]
1653
parents_map = graph.get_parent_map([current_rev_id])
1654
new_history.reverse()
1658
def generate_revision_history(self, revision_id, last_rev=None,
1660
"""Create a new revision history that will finish with revision_id.
1662
:param revision_id: the new tip to use.
1663
:param last_rev: The previous last_revision. If not None, then this
1664
must be a ancestory of revision_id, or DivergedBranches is raised.
1665
:param other_branch: The other branch that DivergedBranches should
1666
raise with respect to.
1668
self.set_revision_history(self._lefthand_history(revision_id,
1669
last_rev, other_branch))
2509
old_revno, old_revid = self.last_revision_info()
2510
if self._get_append_revisions_only():
2511
self._check_history_violation(revision_id)
2512
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2513
self._write_last_revision_info(revno, revision_id)
2514
self._clear_cached_state()
2515
self._last_revision_info_cache = revno, revision_id
2516
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
1671
2518
def basis_tree(self):
1672
2519
"""See Branch.basis_tree."""
1673
2520
return self.repository.revision_tree(self.last_revision())
1676
def pull(self, source, overwrite=False, stop_revision=None,
1677
_hook_master=None, run_hooks=True, possible_transports=None,
1678
_override_hook_target=None):
1681
:param _hook_master: Private parameter - set the branch to
1682
be supplied as the master to pull hooks.
1683
:param run_hooks: Private parameter - if false, this branch
1684
is being called because it's the master of the primary branch,
1685
so it should not run its hooks.
1686
:param _override_hook_target: Private parameter - set the branch to be
1687
supplied as the target_branch to pull hooks.
1689
result = PullResult()
1690
result.source_branch = source
1691
if _override_hook_target is None:
1692
result.target_branch = self
1694
result.target_branch = _override_hook_target
1697
# We assume that during 'pull' the local repository is closer than
1699
graph = self.repository.get_graph(source.repository)
1700
result.old_revno, result.old_revid = self.last_revision_info()
1701
self.update_revisions(source, stop_revision, overwrite=overwrite,
1703
result.tag_conflicts = source.tags.merge_to(self.tags, overwrite)
1704
result.new_revno, result.new_revid = self.last_revision_info()
1706
result.master_branch = _hook_master
1707
result.local_branch = result.target_branch
1709
result.master_branch = result.target_branch
1710
result.local_branch = None
1712
for hook in Branch.hooks['post_pull']:
1718
2522
def _get_parent_location(self):
1719
2523
_locs = ['parent', 'pull', 'x-pull']
1720
2524
for l in _locs:
1728
def push(self, target, overwrite=False, stop_revision=None,
1729
_override_hook_source_branch=None):
1732
This is the basic concrete implementation of push()
1734
:param _override_hook_source_branch: If specified, run
1735
the hooks passing this Branch as the source, rather than self.
1736
This is for use of RemoteBranch, where push is delegated to the
1737
underlying vfs-based Branch.
1739
# TODO: Public option to disable running hooks - should be trivial but
1743
result = self._push_with_bound_branches(target, overwrite,
1745
_override_hook_source_branch=_override_hook_source_branch)
1750
def _push_with_bound_branches(self, target, overwrite,
1752
_override_hook_source_branch=None):
1753
"""Push from self into target, and into target's master if any.
1755
This is on the base BzrBranch class even though it doesn't support
1756
bound branches because the *target* might be bound.
1759
if _override_hook_source_branch:
1760
result.source_branch = _override_hook_source_branch
1761
for hook in Branch.hooks['post_push']:
1764
bound_location = target.get_bound_location()
1765
if bound_location and target.base != bound_location:
1766
# there is a master branch.
1768
# XXX: Why the second check? Is it even supported for a branch to
1769
# be bound to itself? -- mbp 20070507
1770
master_branch = target.get_master_branch()
1771
master_branch.lock_write()
1773
# push into the master from this branch.
1774
self._basic_push(master_branch, overwrite, stop_revision)
1775
# and push into the target branch from this. Note that we push from
1776
# this branch again, because its considered the highest bandwidth
1778
result = self._basic_push(target, overwrite, stop_revision)
1779
result.master_branch = master_branch
1780
result.local_branch = target
1784
master_branch.unlock()
1787
result = self._basic_push(target, overwrite, stop_revision)
1788
# TODO: Why set master_branch and local_branch if there's no
1789
# binding? Maybe cleaner to just leave them unset? -- mbp
1791
result.master_branch = target
1792
result.local_branch = None
1796
def _basic_push(self, target, overwrite, stop_revision):
1797
"""Basic implementation of push without bound branches or hooks.
1799
Must be called with self read locked and target write locked.
1801
result = PushResult()
1802
result.source_branch = self
1803
result.target_branch = target
1804
result.old_revno, result.old_revid = target.last_revision_info()
1806
# We assume that during 'push' this repository is closer than
1808
graph = self.repository.get_graph(target.repository)
1809
target.update_revisions(self, stop_revision, overwrite=overwrite,
1811
result.tag_conflicts = self.tags.merge_to(target.tags, overwrite)
1812
result.new_revno, result.new_revid = target.last_revision_info()
1815
def get_parent(self):
1816
"""See Branch.get_parent."""
1817
parent = self._get_parent_location()
1820
# This is an old-format absolute path to a local branch
1821
# turn it into a url
1822
if parent.startswith('/'):
1823
parent = urlutils.local_path_to_url(parent.decode('utf8'))
1825
return urlutils.join(self.base[:-1], parent)
1826
except errors.InvalidURLJoin, e:
1827
raise errors.InaccessibleParent(parent, self.base)
1829
2531
def get_stacked_on_url(self):
1830
raise errors.UnstackableBranchFormat(self._format, self.base)
2532
raise errors.UnstackableBranchFormat(self._format, self.user_url)
1832
2534
def set_push_location(self, location):
1833
2535
"""See Branch.set_push_location."""
1860
2544
self._transport.put_bytes('parent', url + '\n',
1861
2545
mode=self.bzrdir._get_file_mode())
1863
def set_stacked_on_url(self, url):
1864
raise errors.UnstackableBranchFormat(self._format, self.base)
1867
class BzrBranch5(BzrBranch):
1868
"""A format 5 branch. This supports new features over plain branches.
1870
It has support for a master_branch which is the data for bound branches.
1874
def pull(self, source, overwrite=False, stop_revision=None,
1875
run_hooks=True, possible_transports=None,
1876
_override_hook_target=None):
1877
"""Pull from source into self, updating my master if any.
1879
:param run_hooks: Private parameter - if false, this branch
1880
is being called because it's the master of the primary branch,
1881
so it should not run its hooks.
1883
bound_location = self.get_bound_location()
1884
master_branch = None
1885
if bound_location and source.base != bound_location:
1886
# not pulling from master, so we need to update master.
1887
master_branch = self.get_master_branch(possible_transports)
1888
master_branch.lock_write()
1891
# pull from source into master.
1892
master_branch.pull(source, overwrite, stop_revision,
1894
return super(BzrBranch5, self).pull(source, overwrite,
1895
stop_revision, _hook_master=master_branch,
1896
run_hooks=run_hooks,
1897
_override_hook_target=_override_hook_target)
1900
master_branch.unlock()
1902
def get_bound_location(self):
1904
return self._transport.get_bytes('bound')[:-1]
1905
except errors.NoSuchFile:
1909
def get_master_branch(self, possible_transports=None):
1910
"""Return the branch we are bound to.
1912
:return: Either a Branch, or None
1914
This could memoise the branch, but if thats done
1915
it must be revalidated on each new lock.
1916
So for now we just don't memoise it.
1917
# RBC 20060304 review this decision.
1919
bound_loc = self.get_bound_location()
1923
return Branch.open(bound_loc,
1924
possible_transports=possible_transports)
1925
except (errors.NotBranchError, errors.ConnectionError), e:
1926
raise errors.BoundBranchConnectionFailure(
1930
def set_bound_location(self, location):
1931
"""Set the target where this branch is bound to.
1933
:param location: URL to the target branch
1936
self._transport.put_bytes('bound', location+'\n',
1937
mode=self.bzrdir._get_file_mode())
1940
self._transport.delete('bound')
1941
except errors.NoSuchFile:
2549
"""If bound, unbind"""
2550
return self.set_bound_location(None)
1945
2552
@needs_write_lock
1946
2553
def bind(self, other):
2041
2650
Use set_last_revision_info to perform this safely.
2043
2652
Does not update the revision_history cache.
2044
Intended to be called by set_last_revision_info and
2045
_write_revision_history.
2047
2654
revision_id = _mod_revision.ensure_null(revision_id)
2048
2655
out_string = '%d %s\n' % (revno, revision_id)
2049
2656
self._transport.put_bytes('last-revision', out_string,
2050
2657
mode=self.bzrdir._get_file_mode())
2660
class FullHistoryBzrBranch(BzrBranch):
2661
"""Bzr branch which contains the full revision history."""
2052
2663
@needs_write_lock
2053
2664
def set_last_revision_info(self, revno, revision_id):
2665
if not revision_id or not isinstance(revision_id, basestring):
2666
raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2054
2667
revision_id = _mod_revision.ensure_null(revision_id)
2055
old_revno, old_revid = self.last_revision_info()
2056
if self._get_append_revisions_only():
2057
self._check_history_violation(revision_id)
2058
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2059
self._write_last_revision_info(revno, revision_id)
2668
# this old format stores the full history, but this api doesn't
2669
# provide it, so we must generate, and might as well check it's
2671
history = self._lefthand_history(revision_id)
2672
if len(history) != revno:
2673
raise AssertionError('%d != %d' % (len(history), revno))
2674
self._set_revision_history(history)
2676
def _read_last_revision_info(self):
2677
rh = self.revision_history()
2680
return (revno, rh[-1])
2682
return (0, _mod_revision.NULL_REVISION)
2684
@deprecated_method(deprecated_in((2, 4, 0)))
2686
def set_revision_history(self, rev_history):
2687
"""See Branch.set_revision_history."""
2688
self._set_revision_history(rev_history)
2690
def _set_revision_history(self, rev_history):
2691
if 'evil' in debug.debug_flags:
2692
mutter_callsite(3, "set_revision_history scales with history.")
2693
check_not_reserved_id = _mod_revision.check_not_reserved_id
2694
for rev_id in rev_history:
2695
check_not_reserved_id(rev_id)
2696
if Branch.hooks['post_change_branch_tip']:
2697
# Don't calculate the last_revision_info() if there are no hooks
2699
old_revno, old_revid = self.last_revision_info()
2700
if len(rev_history) == 0:
2701
revid = _mod_revision.NULL_REVISION
2703
revid = rev_history[-1]
2704
self._run_pre_change_branch_tip_hooks(len(rev_history), revid)
2705
self._write_revision_history(rev_history)
2060
2706
self._clear_cached_state()
2061
self._last_revision_info_cache = revno, revision_id
2062
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2707
self._cache_revision_history(rev_history)
2708
for hook in Branch.hooks['set_rh']:
2709
hook(self, rev_history)
2710
if Branch.hooks['post_change_branch_tip']:
2711
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2713
def _write_revision_history(self, history):
2714
"""Factored out of set_revision_history.
2716
This performs the actual writing to disk.
2717
It is intended to be called by set_revision_history."""
2718
self._transport.put_bytes(
2719
'revision-history', '\n'.join(history),
2720
mode=self.bzrdir._get_file_mode())
2722
def _gen_revision_history(self):
2723
history = self._transport.get_bytes('revision-history').split('\n')
2724
if history[-1:] == ['']:
2725
# There shouldn't be a trailing newline, but just in case.
2729
def _synchronize_history(self, destination, revision_id):
2730
if not isinstance(destination, FullHistoryBzrBranch):
2731
super(BzrBranch, self)._synchronize_history(
2732
destination, revision_id)
2734
if revision_id == _mod_revision.NULL_REVISION:
2737
new_history = self.revision_history()
2738
if revision_id is not None and new_history != []:
2740
new_history = new_history[:new_history.index(revision_id) + 1]
2742
rev = self.repository.get_revision(revision_id)
2743
new_history = rev.get_history(self.repository)[1:]
2744
destination._set_revision_history(new_history)
2747
def generate_revision_history(self, revision_id, last_rev=None,
2749
"""Create a new revision history that will finish with revision_id.
2751
:param revision_id: the new tip to use.
2752
:param last_rev: The previous last_revision. If not None, then this
2753
must be a ancestory of revision_id, or DivergedBranches is raised.
2754
:param other_branch: The other branch that DivergedBranches should
2755
raise with respect to.
2757
self._set_revision_history(self._lefthand_history(revision_id,
2758
last_rev, other_branch))
2761
class BzrBranch5(FullHistoryBzrBranch):
2762
"""A format 5 branch. This supports new features over plain branches.
2764
It has support for a master_branch which is the data for bound branches.
2768
class BzrBranch8(BzrBranch):
2769
"""A branch that stores tree-reference locations."""
2771
def _open_hook(self):
2772
if self._ignore_fallbacks:
2775
url = self.get_stacked_on_url()
2776
except (errors.UnstackableRepositoryFormat, errors.NotStacked,
2777
errors.UnstackableBranchFormat):
2780
for hook in Branch.hooks['transform_fallback_location']:
2781
url = hook(self, url)
2783
hook_name = Branch.hooks.get_hook_name(hook)
2784
raise AssertionError(
2785
"'transform_fallback_location' hook %s returned "
2786
"None, not a URL." % hook_name)
2787
self._activate_fallback_location(url)
2789
def __init__(self, *args, **kwargs):
2790
self._ignore_fallbacks = kwargs.get('ignore_fallbacks', False)
2791
super(BzrBranch8, self).__init__(*args, **kwargs)
2792
self._last_revision_info_cache = None
2793
self._reference_info = None
2795
def _clear_cached_state(self):
2796
super(BzrBranch8, self)._clear_cached_state()
2797
self._last_revision_info_cache = None
2798
self._reference_info = None
2064
2800
def _check_history_violation(self, revision_id):
2065
last_revision = _mod_revision.ensure_null(self.last_revision())
2801
current_revid = self.last_revision()
2802
last_revision = _mod_revision.ensure_null(current_revid)
2066
2803
if _mod_revision.is_null(last_revision):
2068
if last_revision not in self._lefthand_history(revision_id):
2069
raise errors.AppendRevisionsOnlyViolation(self.base)
2805
graph = self.repository.get_graph()
2806
for lh_ancestor in graph.iter_lefthand_ancestry(revision_id):
2807
if lh_ancestor == current_revid:
2809
raise errors.AppendRevisionsOnlyViolation(self.user_url)
2071
2811
def _gen_revision_history(self):
2072
2812
"""Generate the revision history from last revision
2130
2825
"""Set the parent branch"""
2131
2826
return self._get_config_location('parent_location')
2829
def _set_all_reference_info(self, info_dict):
2830
"""Replace all reference info stored in a branch.
2832
:param info_dict: A dict of {file_id: (tree_path, branch_location)}
2835
writer = rio.RioWriter(s)
2836
for key, (tree_path, branch_location) in info_dict.iteritems():
2837
stanza = rio.Stanza(file_id=key, tree_path=tree_path,
2838
branch_location=branch_location)
2839
writer.write_stanza(stanza)
2840
self._transport.put_bytes('references', s.getvalue())
2841
self._reference_info = info_dict
2844
def _get_all_reference_info(self):
2845
"""Return all the reference info stored in a branch.
2847
:return: A dict of {file_id: (tree_path, branch_location)}
2849
if self._reference_info is not None:
2850
return self._reference_info
2851
rio_file = self._transport.get('references')
2853
stanzas = rio.read_stanzas(rio_file)
2854
info_dict = dict((s['file_id'], (s['tree_path'],
2855
s['branch_location'])) for s in stanzas)
2858
self._reference_info = info_dict
2861
def set_reference_info(self, file_id, tree_path, branch_location):
2862
"""Set the branch location to use for a tree reference.
2864
:param file_id: The file-id of the tree reference.
2865
:param tree_path: The path of the tree reference in the tree.
2866
:param branch_location: The location of the branch to retrieve tree
2869
info_dict = self._get_all_reference_info()
2870
info_dict[file_id] = (tree_path, branch_location)
2871
if None in (tree_path, branch_location):
2872
if tree_path is not None:
2873
raise ValueError('tree_path must be None when branch_location'
2875
if branch_location is not None:
2876
raise ValueError('branch_location must be None when tree_path'
2878
del info_dict[file_id]
2879
self._set_all_reference_info(info_dict)
2881
def get_reference_info(self, file_id):
2882
"""Get the tree_path and branch_location for a tree reference.
2884
:return: a tuple of (tree_path, branch_location)
2886
return self._get_all_reference_info().get(file_id, (None, None))
2888
def reference_parent(self, file_id, path, possible_transports=None):
2889
"""Return the parent branch for a tree-reference file_id.
2891
:param file_id: The file_id of the tree reference
2892
:param path: The path of the file_id in the tree
2893
:return: A branch associated with the file_id
2895
branch_location = self.get_reference_info(file_id)[1]
2896
if branch_location is None:
2897
return Branch.reference_parent(self, file_id, path,
2898
possible_transports)
2899
branch_location = urlutils.join(self.user_url, branch_location)
2900
return Branch.open(branch_location,
2901
possible_transports=possible_transports)
2133
2903
def set_push_location(self, location):
2134
2904
"""See Branch.set_push_location."""
2135
2905
self._set_config_location('push_location', location)
2137
2907
def set_bound_location(self, location):
2138
2908
"""See Branch.set_push_location."""
2909
self._master_branch_cache = None
2140
2911
config = self.get_config()
2141
2912
if location is None:
2169
2940
return self._get_bound_location(False)
2171
2942
def get_stacked_on_url(self):
2172
self._check_stackable_repo()
2173
stacked_url = self._get_config_location('stacked_on_location')
2943
# you can always ask for the URL; but you might not be able to use it
2944
# if the repo can't support stacking.
2945
## self._check_stackable_repo()
2946
# stacked_on_location is only ever defined in branch.conf, so don't
2947
# waste effort reading the whole stack of config files.
2948
config = self.get_config()._get_branch_data_config()
2949
stacked_url = self._get_config_location('stacked_on_location',
2174
2951
if stacked_url is None:
2175
2952
raise errors.NotStacked(self)
2176
2953
return stacked_url
2178
def set_append_revisions_only(self, enabled):
2183
self.get_config().set_user_option('append_revisions_only', value,
2186
def set_stacked_on_url(self, url):
2187
self._check_stackable_repo()
2190
old_url = self.get_stacked_on_url()
2191
except (errors.NotStacked, errors.UnstackableBranchFormat,
2192
errors.UnstackableRepositoryFormat):
2195
# repositories don't offer an interface to remove fallback
2196
# repositories today; take the conceptually simpler option and just
2198
self.repository = self.bzrdir.find_repository()
2199
# for every revision reference the branch has, ensure it is pulled
2201
source_repository = self._get_fallback_repository(old_url)
2202
for revision_id in chain([self.last_revision()],
2203
self.tags.get_reverse_tag_dict()):
2204
self.repository.fetch(source_repository, revision_id,
2207
self._activate_fallback_location(url)
2208
# write this out after the repository is stacked to avoid setting a
2209
# stacked config that doesn't work.
2210
self._set_config_location('stacked_on_location', url)
2212
2955
def _get_append_revisions_only(self):
2213
value = self.get_config().get_user_option('append_revisions_only')
2214
return value == 'True'
2216
def _synchronize_history(self, destination, revision_id):
2217
"""Synchronize last revision and revision history between branches.
2219
This version is most efficient when the destination is also a
2220
BzrBranch6, but works for BzrBranch5, as long as the destination's
2221
repository contains all the lefthand ancestors of the intended
2222
last_revision. If not, set_last_revision_info will fail.
2224
:param destination: The branch to copy the history into
2225
:param revision_id: The revision-id to truncate history at. May
2226
be None to copy complete history.
2228
source_revno, source_revision_id = self.last_revision_info()
2229
if revision_id is None:
2230
revno, revision_id = source_revno, source_revision_id
2231
elif source_revision_id == revision_id:
2232
# we know the revno without needing to walk all of history
2233
revno = source_revno
2235
# To figure out the revno for a random revision, we need to build
2236
# the revision history, and count its length.
2237
# We don't care about the order, just how long it is.
2238
# Alternatively, we could start at the current location, and count
2239
# backwards. But there is no guarantee that we will find it since
2240
# it may be a merged revision.
2241
revno = len(list(self.repository.iter_reverse_revision_history(
2243
destination.set_last_revision_info(revno, revision_id)
2245
def _make_tags(self):
2246
return BasicTags(self)
2249
def generate_revision_history(self, revision_id, last_rev=None,
2251
"""See BzrBranch5.generate_revision_history"""
2252
history = self._lefthand_history(revision_id, last_rev, other_branch)
2253
revno = len(history)
2254
self.set_last_revision_info(revno, revision_id)
2956
return self.get_config(
2957
).get_user_option_as_bool('append_revisions_only')
2256
2959
@needs_read_lock
2257
2960
def get_rev_id(self, revno, history=None):
2429
3163
branch._set_config_location('stacked_on_location', '')
2430
3164
# update target format
2431
3165
branch._transport.put_bytes('format', format.get_format_string())
3168
class Converter7to8(object):
3169
"""Perform an in-place upgrade of format 7 to format 8"""
3171
def convert(self, branch):
3172
format = BzrBranchFormat8()
3173
branch._transport.put_bytes('references', '')
3174
# update target format
3175
branch._transport.put_bytes('format', format.get_format_string())
3178
class InterBranch(InterObject):
3179
"""This class represents operations taking place between two branches.
3181
Its instances have methods like pull() and push() and contain
3182
references to the source and target repositories these operations
3183
can be carried out on.
3187
"""The available optimised InterBranch types."""
3190
def _get_branch_formats_to_test(klass):
3191
"""Return an iterable of format tuples for testing.
3193
:return: An iterable of (from_format, to_format) to use when testing
3194
this InterBranch class. Each InterBranch class should define this
3197
raise NotImplementedError(klass._get_branch_formats_to_test)
3200
def pull(self, overwrite=False, stop_revision=None,
3201
possible_transports=None, local=False):
3202
"""Mirror source into target branch.
3204
The target branch is considered to be 'local', having low latency.
3206
:returns: PullResult instance
3208
raise NotImplementedError(self.pull)
3211
def push(self, overwrite=False, stop_revision=None, lossy=False,
3212
_override_hook_source_branch=None):
3213
"""Mirror the source branch into the target branch.
3215
The source branch is considered to be 'local', having low latency.
3217
raise NotImplementedError(self.push)
3220
def copy_content_into(self, revision_id=None):
3221
"""Copy the content of source into target
3223
revision_id: if not None, the revision history in the new branch will
3224
be truncated to end with revision_id.
3226
raise NotImplementedError(self.copy_content_into)
3229
def fetch(self, stop_revision=None, limit=None):
3232
:param stop_revision: Last revision to fetch
3233
:param limit: Optional rough limit of revisions to fetch
3235
raise NotImplementedError(self.fetch)
3238
class GenericInterBranch(InterBranch):
3239
"""InterBranch implementation that uses public Branch functions."""
3242
def is_compatible(klass, source, target):
3243
# GenericBranch uses the public API, so always compatible
3247
def _get_branch_formats_to_test(klass):
3248
return [(format_registry.get_default(), format_registry.get_default())]
3251
def unwrap_format(klass, format):
3252
if isinstance(format, remote.RemoteBranchFormat):
3253
format._ensure_real()
3254
return format._custom_format
3258
def copy_content_into(self, revision_id=None):
3259
"""Copy the content of source into target
3261
revision_id: if not None, the revision history in the new branch will
3262
be truncated to end with revision_id.
3264
self.source.update_references(self.target)
3265
self.source._synchronize_history(self.target, revision_id)
3267
parent = self.source.get_parent()
3268
except errors.InaccessibleParent, e:
3269
mutter('parent was not accessible to copy: %s', e)
3272
self.target.set_parent(parent)
3273
if self.source._push_should_merge_tags():
3274
self.source.tags.merge_to(self.target.tags)
3277
def fetch(self, stop_revision=None, limit=None):
3278
if self.target.base == self.source.base:
3280
self.source.lock_read()
3282
fetch_spec_factory = fetch.FetchSpecFactory()
3283
fetch_spec_factory.source_branch = self.source
3284
fetch_spec_factory.source_branch_stop_revision_id = stop_revision
3285
fetch_spec_factory.source_repo = self.source.repository
3286
fetch_spec_factory.target_repo = self.target.repository
3287
fetch_spec_factory.target_repo_kind = fetch.TargetRepoKinds.PREEXISTING
3288
fetch_spec_factory.limit = limit
3289
fetch_spec = fetch_spec_factory.make_fetch_spec()
3290
return self.target.repository.fetch(self.source.repository,
3291
fetch_spec=fetch_spec)
3293
self.source.unlock()
3296
def _update_revisions(self, stop_revision=None, overwrite=False,
3298
other_revno, other_last_revision = self.source.last_revision_info()
3299
stop_revno = None # unknown
3300
if stop_revision is None:
3301
stop_revision = other_last_revision
3302
if _mod_revision.is_null(stop_revision):
3303
# if there are no commits, we're done.
3305
stop_revno = other_revno
3307
# what's the current last revision, before we fetch [and change it
3309
last_rev = _mod_revision.ensure_null(self.target.last_revision())
3310
# we fetch here so that we don't process data twice in the common
3311
# case of having something to pull, and so that the check for
3312
# already merged can operate on the just fetched graph, which will
3313
# be cached in memory.
3314
self.fetch(stop_revision=stop_revision)
3315
# Check to see if one is an ancestor of the other
3318
graph = self.target.repository.get_graph()
3319
if self.target._check_if_descendant_or_diverged(
3320
stop_revision, last_rev, graph, self.source):
3321
# stop_revision is a descendant of last_rev, but we aren't
3322
# overwriting, so we're done.
3324
if stop_revno is None:
3326
graph = self.target.repository.get_graph()
3327
this_revno, this_last_revision = \
3328
self.target.last_revision_info()
3329
stop_revno = graph.find_distance_to_null(stop_revision,
3330
[(other_last_revision, other_revno),
3331
(this_last_revision, this_revno)])
3332
self.target.set_last_revision_info(stop_revno, stop_revision)
3335
def pull(self, overwrite=False, stop_revision=None,
3336
possible_transports=None, run_hooks=True,
3337
_override_hook_target=None, local=False):
3338
"""Pull from source into self, updating my master if any.
3340
:param run_hooks: Private parameter - if false, this branch
3341
is being called because it's the master of the primary branch,
3342
so it should not run its hooks.
3344
bound_location = self.target.get_bound_location()
3345
if local and not bound_location:
3346
raise errors.LocalRequiresBoundBranch()
3347
master_branch = None
3348
source_is_master = False
3350
# bound_location comes from a config file, some care has to be
3351
# taken to relate it to source.user_url
3352
normalized = urlutils.normalize_url(bound_location)
3354
relpath = self.source.user_transport.relpath(normalized)
3355
source_is_master = (relpath == '')
3356
except (errors.PathNotChild, errors.InvalidURL):
3357
source_is_master = False
3358
if not local and bound_location and not source_is_master:
3359
# not pulling from master, so we need to update master.
3360
master_branch = self.target.get_master_branch(possible_transports)
3361
master_branch.lock_write()
3364
# pull from source into master.
3365
master_branch.pull(self.source, overwrite, stop_revision,
3367
return self._pull(overwrite,
3368
stop_revision, _hook_master=master_branch,
3369
run_hooks=run_hooks,
3370
_override_hook_target=_override_hook_target,
3371
merge_tags_to_master=not source_is_master)
3374
master_branch.unlock()
3376
def push(self, overwrite=False, stop_revision=None, lossy=False,
3377
_override_hook_source_branch=None):
3378
"""See InterBranch.push.
3380
This is the basic concrete implementation of push()
3382
:param _override_hook_source_branch: If specified, run the hooks
3383
passing this Branch as the source, rather than self. This is for
3384
use of RemoteBranch, where push is delegated to the underlying
3388
raise errors.LossyPushToSameVCS(self.source, self.target)
3389
# TODO: Public option to disable running hooks - should be trivial but
3392
op = cleanup.OperationWithCleanups(self._push_with_bound_branches)
3393
op.add_cleanup(self.source.lock_read().unlock)
3394
op.add_cleanup(self.target.lock_write().unlock)
3395
return op.run(overwrite, stop_revision,
3396
_override_hook_source_branch=_override_hook_source_branch)
3398
def _basic_push(self, overwrite, stop_revision):
3399
"""Basic implementation of push without bound branches or hooks.
3401
Must be called with source read locked and target write locked.
3403
result = BranchPushResult()
3404
result.source_branch = self.source
3405
result.target_branch = self.target
3406
result.old_revno, result.old_revid = self.target.last_revision_info()
3407
self.source.update_references(self.target)
3408
if result.old_revid != stop_revision:
3409
# We assume that during 'push' this repository is closer than
3411
graph = self.source.repository.get_graph(self.target.repository)
3412
self._update_revisions(stop_revision, overwrite=overwrite,
3414
if self.source._push_should_merge_tags():
3415
result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
3417
result.new_revno, result.new_revid = self.target.last_revision_info()
3420
def _push_with_bound_branches(self, operation, overwrite, stop_revision,
3421
_override_hook_source_branch=None):
3422
"""Push from source into target, and into target's master if any.
3425
if _override_hook_source_branch:
3426
result.source_branch = _override_hook_source_branch
3427
for hook in Branch.hooks['post_push']:
3430
bound_location = self.target.get_bound_location()
3431
if bound_location and self.target.base != bound_location:
3432
# there is a master branch.
3434
# XXX: Why the second check? Is it even supported for a branch to
3435
# be bound to itself? -- mbp 20070507
3436
master_branch = self.target.get_master_branch()
3437
master_branch.lock_write()
3438
operation.add_cleanup(master_branch.unlock)
3439
# push into the master from the source branch.
3440
master_inter = InterBranch.get(self.source, master_branch)
3441
master_inter._basic_push(overwrite, stop_revision)
3442
# and push into the target branch from the source. Note that
3443
# we push from the source branch again, because it's considered
3444
# the highest bandwidth repository.
3445
result = self._basic_push(overwrite, stop_revision)
3446
result.master_branch = master_branch
3447
result.local_branch = self.target
3449
master_branch = None
3451
result = self._basic_push(overwrite, stop_revision)
3452
# TODO: Why set master_branch and local_branch if there's no
3453
# binding? Maybe cleaner to just leave them unset? -- mbp
3455
result.master_branch = self.target
3456
result.local_branch = None
3460
def _pull(self, overwrite=False, stop_revision=None,
3461
possible_transports=None, _hook_master=None, run_hooks=True,
3462
_override_hook_target=None, local=False,
3463
merge_tags_to_master=True):
3466
This function is the core worker, used by GenericInterBranch.pull to
3467
avoid duplication when pulling source->master and source->local.
3469
:param _hook_master: Private parameter - set the branch to
3470
be supplied as the master to pull hooks.
3471
:param run_hooks: Private parameter - if false, this branch
3472
is being called because it's the master of the primary branch,
3473
so it should not run its hooks.
3474
is being called because it's the master of the primary branch,
3475
so it should not run its hooks.
3476
:param _override_hook_target: Private parameter - set the branch to be
3477
supplied as the target_branch to pull hooks.
3478
:param local: Only update the local branch, and not the bound branch.
3480
# This type of branch can't be bound.
3482
raise errors.LocalRequiresBoundBranch()
3483
result = PullResult()
3484
result.source_branch = self.source
3485
if _override_hook_target is None:
3486
result.target_branch = self.target
3488
result.target_branch = _override_hook_target
3489
self.source.lock_read()
3491
# We assume that during 'pull' the target repository is closer than
3493
self.source.update_references(self.target)
3494
graph = self.target.repository.get_graph(self.source.repository)
3495
# TODO: Branch formats should have a flag that indicates
3496
# that revno's are expensive, and pull() should honor that flag.
3498
result.old_revno, result.old_revid = \
3499
self.target.last_revision_info()
3500
self._update_revisions(stop_revision, overwrite=overwrite,
3502
# TODO: The old revid should be specified when merging tags,
3503
# so a tags implementation that versions tags can only
3504
# pull in the most recent changes. -- JRV20090506
3505
result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
3506
overwrite, ignore_master=not merge_tags_to_master)
3507
result.new_revno, result.new_revid = self.target.last_revision_info()
3509
result.master_branch = _hook_master
3510
result.local_branch = result.target_branch
3512
result.master_branch = result.target_branch
3513
result.local_branch = None
3515
for hook in Branch.hooks['post_pull']:
3518
self.source.unlock()
3522
InterBranch.register_optimiser(GenericInterBranch)
added
removed
bzrlib/branch.py
