148
190
possible_transports)
149
191
return control.open_branch(), relpath
193
def _push_should_merge_tags(self):
194
"""Should _basic_push merge this branch's tags into the target?
196
The default implementation returns False if this branch has no tags,
197
and True the rest of the time. Subclasses may override this.
199
return self.supports_tags() and self.tags.get_tag_dict()
151
201
def get_config(self):
152
202
return BranchConfig(self)
155
return self.get_config().get_nickname()
204
def _get_config(self):
205
"""Get the concrete config for just the config in this branch.
207
This is not intended for client use; see Branch.get_config for the
212
:return: An object supporting get_option and set_option.
214
raise NotImplementedError(self._get_config)
216
def _get_fallback_repository(self, url):
217
"""Get the repository we fallback to at url."""
218
url = urlutils.join(self.base, url)
219
a_bzrdir = bzrdir.BzrDir.open(url,
220
possible_transports=[self.bzrdir.root_transport])
221
return a_bzrdir.open_branch().repository
223
def _get_tags_bytes(self):
224
"""Get the bytes of a serialised tags dict.
226
Note that not all branches support tags, nor do all use the same tags
227
logic: this method is specific to BasicTags. Other tag implementations
228
may use the same method name and behave differently, safely, because
229
of the double-dispatch via
230
format.make_tags->tags_instance->get_tags_dict.
232
:return: The bytes of the tags file.
233
:seealso: Branch._set_tags_bytes.
235
return self._transport.get_bytes('tags')
237
def _get_nick(self, local=False, possible_transports=None):
238
config = self.get_config()
239
# explicit overrides master, but don't look for master if local is True
240
if not local and not config.has_explicit_nickname():
242
master = self.get_master_branch(possible_transports)
243
if master is not None:
244
# return the master branch value
246
except errors.BzrError, e:
247
# Silently fall back to local implicit nick if the master is
249
mutter("Could not connect to bound branch, "
250
"falling back to local nick.\n " + str(e))
251
return config.get_nickname()
157
253
def _set_nick(self, nick):
158
254
self.get_config().set_user_option('nickname', nick, warn_masked=True)
179
302
raise NotImplementedError(self.get_physical_lock_status)
305
def dotted_revno_to_revision_id(self, revno, _cache_reverse=False):
306
"""Return the revision_id for a dotted revno.
308
:param revno: a tuple like (1,) or (1,1,2)
309
:param _cache_reverse: a private parameter enabling storage
310
of the reverse mapping in a top level cache. (This should
311
only be done in selective circumstances as we want to
312
avoid having the mapping cached multiple times.)
313
:return: the revision_id
314
:raises errors.NoSuchRevision: if the revno doesn't exist
316
rev_id = self._do_dotted_revno_to_revision_id(revno)
318
self._partial_revision_id_to_revno_cache[rev_id] = revno
321
def _do_dotted_revno_to_revision_id(self, revno):
322
"""Worker function for dotted_revno_to_revision_id.
324
Subclasses should override this if they wish to
325
provide a more efficient implementation.
328
return self.get_rev_id(revno[0])
329
revision_id_to_revno = self.get_revision_id_to_revno_map()
330
revision_ids = [revision_id for revision_id, this_revno
331
in revision_id_to_revno.iteritems()
332
if revno == this_revno]
333
if len(revision_ids) == 1:
334
return revision_ids[0]
336
revno_str = '.'.join(map(str, revno))
337
raise errors.NoSuchRevision(self, revno_str)
340
def revision_id_to_dotted_revno(self, revision_id):
341
"""Given a revision id, return its dotted revno.
343
:return: a tuple like (1,) or (400,1,3).
345
return self._do_revision_id_to_dotted_revno(revision_id)
347
def _do_revision_id_to_dotted_revno(self, revision_id):
348
"""Worker function for revision_id_to_revno."""
349
# Try the caches if they are loaded
350
result = self._partial_revision_id_to_revno_cache.get(revision_id)
351
if result is not None:
353
if self._revision_id_to_revno_cache:
354
result = self._revision_id_to_revno_cache.get(revision_id)
356
raise errors.NoSuchRevision(self, revision_id)
357
# Try the mainline as it's optimised
359
revno = self.revision_id_to_revno(revision_id)
361
except errors.NoSuchRevision:
362
# We need to load and use the full revno map after all
363
result = self.get_revision_id_to_revno_map().get(revision_id)
365
raise errors.NoSuchRevision(self, revision_id)
182
369
def get_revision_id_to_revno_map(self):
183
370
"""Return the revision_id => dotted revno map.
209
396
:return: A dictionary mapping revision_id => dotted revno.
211
last_revision = self.last_revision()
212
revision_graph = self.repository.get_revision_graph(last_revision)
213
merge_sorted_revisions = tsort.merge_sort(
218
398
revision_id_to_revno = dict((rev_id, revno)
219
for seq_num, rev_id, depth, revno, end_of_merge
220
in merge_sorted_revisions)
399
for rev_id, depth, revno, end_of_merge
400
in self.iter_merge_sorted_revisions())
221
401
return revision_id_to_revno
404
def iter_merge_sorted_revisions(self, start_revision_id=None,
405
stop_revision_id=None, stop_rule='exclude', direction='reverse'):
406
"""Walk the revisions for a branch in merge sorted order.
408
Merge sorted order is the output from a merge-aware,
409
topological sort, i.e. all parents come before their
410
children going forward; the opposite for reverse.
412
:param start_revision_id: the revision_id to begin walking from.
413
If None, the branch tip is used.
414
:param stop_revision_id: the revision_id to terminate the walk
415
after. If None, the rest of history is included.
416
:param stop_rule: if stop_revision_id is not None, the precise rule
417
to use for termination:
418
* 'exclude' - leave the stop revision out of the result (default)
419
* 'include' - the stop revision is the last item in the result
420
* 'with-merges' - include the stop revision and all of its
421
merged revisions in the result
422
:param direction: either 'reverse' or 'forward':
423
* reverse means return the start_revision_id first, i.e.
424
start at the most recent revision and go backwards in history
425
* forward returns tuples in the opposite order to reverse.
426
Note in particular that forward does *not* do any intelligent
427
ordering w.r.t. depth as some clients of this API may like.
428
(If required, that ought to be done at higher layers.)
430
:return: an iterator over (revision_id, depth, revno, end_of_merge)
433
* revision_id: the unique id of the revision
434
* depth: How many levels of merging deep this node has been
436
* revno_sequence: This field provides a sequence of
437
revision numbers for all revisions. The format is:
438
(REVNO, BRANCHNUM, BRANCHREVNO). BRANCHNUM is the number of the
439
branch that the revno is on. From left to right the REVNO numbers
440
are the sequence numbers within that branch of the revision.
441
* end_of_merge: When True the next node (earlier in history) is
442
part of a different merge.
444
# Note: depth and revno values are in the context of the branch so
445
# we need the full graph to get stable numbers, regardless of the
447
if self._merge_sorted_revisions_cache is None:
448
last_revision = self.last_revision()
449
last_key = (last_revision,)
450
known_graph = self.repository.revisions.get_known_graph_ancestry(
452
self._merge_sorted_revisions_cache = known_graph.merge_sort(
454
filtered = self._filter_merge_sorted_revisions(
455
self._merge_sorted_revisions_cache, start_revision_id,
456
stop_revision_id, stop_rule)
457
if direction == 'reverse':
459
if direction == 'forward':
460
return reversed(list(filtered))
462
raise ValueError('invalid direction %r' % direction)
464
def _filter_merge_sorted_revisions(self, merge_sorted_revisions,
465
start_revision_id, stop_revision_id, stop_rule):
466
"""Iterate over an inclusive range of sorted revisions."""
467
rev_iter = iter(merge_sorted_revisions)
468
if start_revision_id is not None:
469
for node in rev_iter:
470
rev_id = node.key[-1]
471
if rev_id != start_revision_id:
474
# The decision to include the start or not
475
# depends on the stop_rule if a stop is provided
476
# so pop this node back into the iterator
477
rev_iter = chain(iter([node]), rev_iter)
479
if stop_revision_id is None:
481
for node in rev_iter:
482
rev_id = node.key[-1]
483
yield (rev_id, node.merge_depth, node.revno,
485
elif stop_rule == 'exclude':
486
for node in rev_iter:
487
rev_id = node.key[-1]
488
if rev_id == stop_revision_id:
490
yield (rev_id, node.merge_depth, node.revno,
492
elif stop_rule == 'include':
493
for node in rev_iter:
494
rev_id = node.key[-1]
495
yield (rev_id, node.merge_depth, node.revno,
497
if rev_id == stop_revision_id:
499
elif stop_rule == 'with-merges':
500
stop_rev = self.repository.get_revision(stop_revision_id)
501
if stop_rev.parent_ids:
502
left_parent = stop_rev.parent_ids[0]
504
left_parent = _mod_revision.NULL_REVISION
505
for node in rev_iter:
506
rev_id = node.key[-1]
507
if rev_id == left_parent:
509
yield (rev_id, node.merge_depth, node.revno,
512
raise ValueError('invalid stop_rule %r' % stop_rule)
223
514
def leave_lock_in_place(self):
224
515
"""Tell this branch object not to release the physical lock when this
225
516
object is unlocked.
227
518
If lock_write doesn't return a token, then this method is not supported.
229
520
self.control_files.leave_in_place()
355
647
def set_revision_history(self, rev_history):
356
648
raise NotImplementedError(self.set_revision_history)
651
def set_parent(self, url):
652
"""See Branch.set_parent."""
653
# TODO: Maybe delete old location files?
654
# URLs should never be unicode, even on the local fs,
655
# FIXUP this and get_parent in a future branch format bump:
656
# read and rewrite the file. RBC 20060125
658
if isinstance(url, unicode):
660
url = url.encode('ascii')
661
except UnicodeEncodeError:
662
raise errors.InvalidURL(url,
663
"Urls must be 7-bit ascii, "
664
"use bzrlib.urlutils.escape")
665
url = urlutils.relative_url(self.base, url)
666
self._set_parent_location(url)
669
def set_stacked_on_url(self, url):
670
"""Set the URL this branch is stacked against.
672
:raises UnstackableBranchFormat: If the branch does not support
674
:raises UnstackableRepositoryFormat: If the repository does not support
677
if not self._format.supports_stacking():
678
raise errors.UnstackableBranchFormat(self._format, self.base)
679
# XXX: Changing from one fallback repository to another does not check
680
# that all the data you need is present in the new fallback.
681
# Possibly it should.
682
self._check_stackable_repo()
685
old_url = self.get_stacked_on_url()
686
except (errors.NotStacked, errors.UnstackableBranchFormat,
687
errors.UnstackableRepositoryFormat):
691
self._activate_fallback_location(url)
692
# write this out after the repository is stacked to avoid setting a
693
# stacked config that doesn't work.
694
self._set_config_location('stacked_on_location', url)
697
"""Change a branch to be unstacked, copying data as needed.
699
Don't call this directly, use set_stacked_on_url(None).
701
pb = ui.ui_factory.nested_progress_bar()
703
pb.update("Unstacking")
704
# The basic approach here is to fetch the tip of the branch,
705
# including all available ghosts, from the existing stacked
706
# repository into a new repository object without the fallbacks.
708
# XXX: See <https://launchpad.net/bugs/397286> - this may not be
709
# correct for CHKMap repostiories
710
old_repository = self.repository
711
if len(old_repository._fallback_repositories) != 1:
712
raise AssertionError("can't cope with fallback repositories "
713
"of %r" % (self.repository,))
714
# unlock it, including unlocking the fallback
715
old_repository.unlock()
716
old_repository.lock_read()
718
# Repositories don't offer an interface to remove fallback
719
# repositories today; take the conceptually simpler option and just
720
# reopen it. We reopen it starting from the URL so that we
721
# get a separate connection for RemoteRepositories and can
722
# stream from one of them to the other. This does mean doing
723
# separate SSH connection setup, but unstacking is not a
724
# common operation so it's tolerable.
725
new_bzrdir = bzrdir.BzrDir.open(self.bzrdir.root_transport.base)
726
new_repository = new_bzrdir.find_repository()
727
self.repository = new_repository
728
if self.repository._fallback_repositories:
729
raise AssertionError("didn't expect %r to have "
730
"fallback_repositories"
731
% (self.repository,))
732
# this is not paired with an unlock because it's just restoring
733
# the previous state; the lock's released when set_stacked_on_url
735
self.repository.lock_write()
736
# XXX: If you unstack a branch while it has a working tree
737
# with a pending merge, the pending-merged revisions will no
738
# longer be present. You can (probably) revert and remerge.
740
# XXX: This only fetches up to the tip of the repository; it
741
# doesn't bring across any tags. That's fairly consistent
742
# with how branch works, but perhaps not ideal.
743
self.repository.fetch(old_repository,
744
revision_id=self.last_revision(),
747
old_repository.unlock()
751
def _set_tags_bytes(self, bytes):
752
"""Mirror method for _get_tags_bytes.
754
:seealso: Branch._get_tags_bytes.
756
return _run_with_write_locked_target(self, self._transport.put_bytes,
358
759
def _cache_revision_history(self, rev_history):
359
760
"""Set the cached revision history to rev_history.
464
870
common_index = min(self_len, other_len) -1
465
871
if common_index >= 0 and \
466
872
self_history[common_index] != other_history[common_index]:
467
raise DivergedBranches(self, other)
873
raise errors.DivergedBranches(self, other)
469
875
if stop_revision is None:
470
876
stop_revision = other_len
472
assert isinstance(stop_revision, int)
473
878
if stop_revision > other_len:
474
879
raise errors.NoSuchRevision(self, stop_revision)
475
880
return other_history[self_len:stop_revision]
477
def update_revisions(self, other, stop_revision=None):
883
def update_revisions(self, other, stop_revision=None, overwrite=False,
478
885
"""Pull in new perfect-fit revisions.
480
887
:param other: Another Branch to pull from
481
888
:param stop_revision: Updated until the given revision
889
:param overwrite: Always set the branch pointer, rather than checking
890
to see if it is a proper descendant.
891
:param graph: A Graph object that can be used to query history
892
information. This can be None.
484
raise NotImplementedError(self.update_revisions)
895
return InterBranch.get(other, self).update_revisions(stop_revision,
898
def import_last_revision_info(self, source_repo, revno, revid):
899
"""Set the last revision info, importing from another repo if necessary.
901
This is used by the bound branch code to upload a revision to
902
the master branch first before updating the tip of the local branch.
904
:param source_repo: Source repository to optionally fetch from
905
:param revno: Revision number of the new tip
906
:param revid: Revision id of the new tip
908
if not self.repository.has_same_location(source_repo):
909
self.repository.fetch(source_repo, revision_id=revid)
910
self.set_last_revision_info(revno, revid)
486
912
def revision_id_to_revno(self, revision_id):
487
913
"""Given a revision id, return its revno"""
488
914
if _mod_revision.is_null(revision_id):
490
revision_id = osutils.safe_revision_id(revision_id)
491
916
history = self.revision_history()
493
918
return history.index(revision_id) + 1
494
919
except ValueError:
495
920
raise errors.NoSuchRevision(self, revision_id)
497
923
def get_rev_id(self, revno, history=None):
498
924
"""Find the revision id of the specified revno."""
500
926
return _mod_revision.NULL_REVISION
502
history = self.revision_history()
503
if revno <= 0 or revno > len(history):
927
last_revno, last_revid = self.last_revision_info()
928
if revno == last_revno:
930
if revno <= 0 or revno > last_revno:
504
931
raise errors.NoSuchRevision(self, revno)
505
return history[revno - 1]
932
distance_from_last = last_revno - revno
933
if len(self._partial_revision_history_cache) <= distance_from_last:
934
self._extend_partial_history(distance_from_last)
935
return self._partial_revision_history_cache[distance_from_last]
507
def pull(self, source, overwrite=False, stop_revision=None):
938
def pull(self, source, overwrite=False, stop_revision=None,
939
possible_transports=None, *args, **kwargs):
508
940
"""Mirror source into this branch.
510
942
This branch is considered to be 'local', having low latency.
512
944
:returns: PullResult instance
514
raise NotImplementedError(self.pull)
946
return InterBranch.get(source, self).pull(overwrite=overwrite,
947
stop_revision=stop_revision,
948
possible_transports=possible_transports, *args, **kwargs)
516
def push(self, target, overwrite=False, stop_revision=None):
950
def push(self, target, overwrite=False, stop_revision=None, *args,
517
952
"""Mirror this branch into target.
519
954
This branch is considered to be 'local', having low latency.
521
raise NotImplementedError(self.push)
956
return InterBranch.get(self, target).push(overwrite, stop_revision,
959
def lossy_push(self, target, stop_revision=None):
960
"""Push deltas into another branch.
962
:note: This does not, like push, retain the revision ids from
963
the source branch and will, rather than adding bzr-specific
964
metadata, push only those semantics of the revision that can be
965
natively represented by this branch' VCS.
967
:param target: Target branch
968
:param stop_revision: Revision to push, defaults to last revision.
969
:return: BranchPushResult with an extra member revidmap:
970
A dictionary mapping revision ids from the target branch
971
to new revision ids in the target branch, for each
972
revision that was pushed.
974
inter = InterBranch.get(self, target)
975
lossy_push = getattr(inter, "lossy_push", None)
976
if lossy_push is None:
977
raise errors.LossyPushToSameVCS(self, target)
978
return lossy_push(stop_revision)
523
980
def basis_tree(self):
524
981
"""Return `Tree` object for last revision."""
525
982
return self.repository.revision_tree(self.last_revision())
527
def rename_one(self, from_rel, to_rel):
530
This can change the directory or the filename or both.
532
raise NotImplementedError(self.rename_one)
534
def move(self, from_paths, to_name):
537
to_name must exist as a versioned directory.
539
If to_name exists and is a directory, the files are moved into
540
it, keeping their old names. If it is a directory,
542
Note that to_name is only the last component of the new name;
543
this doesn't change the directory.
545
This returns a list of (from_path, to_path) pairs for each
548
raise NotImplementedError(self.move)
550
984
def get_parent(self):
551
985
"""Return the parent location of the branch.
553
This is the default location for push/pull/missing. The usual
987
This is the default location for pull/missing. The usual
554
988
pattern is that the user can override it by specifying a
557
raise NotImplementedError(self.get_parent)
991
parent = self._get_parent_location()
994
# This is an old-format absolute path to a local branch
996
if parent.startswith('/'):
997
parent = urlutils.local_path_to_url(parent.decode('utf8'))
999
return urlutils.join(self.base[:-1], parent)
1000
except errors.InvalidURLJoin, e:
1001
raise errors.InaccessibleParent(parent, self.base)
1003
def _get_parent_location(self):
1004
raise NotImplementedError(self._get_parent_location)
559
1006
def _set_config_location(self, name, url, config=None,
560
1007
make_relative=False):
638
1116
self.check_real_revno(revno)
640
1118
def check_real_revno(self, revno):
642
1120
Check whether a revno corresponds to a real revision.
643
1121
Zero (the NULL revision) is considered invalid
645
1123
if revno < 1 or revno > self.revno():
646
raise InvalidRevisionNumber(revno)
1124
raise errors.InvalidRevisionNumber(revno)
648
1126
@needs_read_lock
649
def clone(self, to_bzrdir, revision_id=None):
1127
def clone(self, to_bzrdir, revision_id=None, repository_policy=None):
650
1128
"""Clone this branch into to_bzrdir preserving all semantic values.
1130
Most API users will want 'create_clone_on_transport', which creates a
1131
new bzrdir and branch on the fly.
652
1133
revision_id: if not None, the revision history in the new branch will
653
1134
be truncated to end with revision_id.
655
result = self._format.initialize(to_bzrdir)
656
self.copy_content_into(result, revision_id=revision_id)
1136
result = to_bzrdir.create_branch()
1139
if repository_policy is not None:
1140
repository_policy.configure_branch(result)
1141
self.copy_content_into(result, revision_id=revision_id)
659
1146
@needs_read_lock
660
def sprout(self, to_bzrdir, revision_id=None):
1147
def sprout(self, to_bzrdir, revision_id=None, repository_policy=None):
661
1148
"""Create a new line of development from the branch, into to_bzrdir.
1150
to_bzrdir controls the branch format.
663
1152
revision_id: if not None, the revision history in the new branch will
664
1153
be truncated to end with revision_id.
666
result = self._format.initialize(to_bzrdir)
667
self.copy_content_into(result, revision_id=revision_id)
668
result.set_parent(self.bzrdir.root_transport.base)
1155
if (repository_policy is not None and
1156
repository_policy.requires_stacking()):
1157
to_bzrdir._format.require_stacking(_skip_repo=True)
1158
result = to_bzrdir.create_branch()
1161
if repository_policy is not None:
1162
repository_policy.configure_branch(result)
1163
self.copy_content_into(result, revision_id=revision_id)
1164
result.set_parent(self.bzrdir.root_transport.base)
671
1169
def _synchronize_history(self, destination, revision_id):
672
1170
"""Synchronize last revision and revision history between branches.
674
1172
This version is most efficient when the destination is also a
675
BzrBranch5, but works for BzrBranch6 as long as the revision
676
history is the true lefthand parent history, and all of the revisions
677
are in the destination's repository. If not, set_revision_history
1173
BzrBranch6, but works for BzrBranch5, as long as the destination's
1174
repository contains all the lefthand ancestors of the intended
1175
last_revision. If not, set_last_revision_info will fail.
680
1177
:param destination: The branch to copy the history into
681
1178
:param revision_id: The revision-id to truncate history at. May
682
1179
be None to copy complete history.
684
if revision_id == _mod_revision.NULL_REVISION:
686
new_history = self.revision_history()
687
if revision_id is not None and new_history != []:
688
revision_id = osutils.safe_revision_id(revision_id)
1181
source_revno, source_revision_id = self.last_revision_info()
1182
if revision_id is None:
1183
revno, revision_id = source_revno, source_revision_id
1185
graph = self.repository.get_graph()
690
new_history = new_history[:new_history.index(revision_id) + 1]
692
rev = self.repository.get_revision(revision_id)
693
new_history = rev.get_history(self.repository)[1:]
694
destination.set_revision_history(new_history)
1187
revno = graph.find_distance_to_null(revision_id,
1188
[(source_revision_id, source_revno)])
1189
except errors.GhostRevisionsHaveNoRevno:
1190
# Default to 1, if we can't find anything else
1192
destination.set_last_revision_info(revno, revision_id)
696
1194
@needs_read_lock
697
1195
def copy_content_into(self, destination, revision_id=None):
710
1209
destination.set_parent(parent)
711
self.tags.merge_to(destination.tags)
1210
if self._push_should_merge_tags():
1211
self.tags.merge_to(destination.tags)
1213
def update_references(self, target):
1214
if not getattr(self._format, 'supports_reference_locations', False):
1216
reference_dict = self._get_all_reference_info()
1217
if len(reference_dict) == 0:
1219
old_base = self.base
1220
new_base = target.base
1221
target_reference_dict = target._get_all_reference_info()
1222
for file_id, (tree_path, branch_location) in (
1223
reference_dict.items()):
1224
branch_location = urlutils.rebase_url(branch_location,
1226
target_reference_dict.setdefault(
1227
file_id, (tree_path, branch_location))
1228
target._set_all_reference_info(target_reference_dict)
713
1230
@needs_read_lock
1231
def check(self, refs):
715
1232
"""Check consistency of the branch.
717
1234
In particular this checks that revisions given in the revision-history
718
do actually match up in the revision graph, and that they're all
1235
do actually match up in the revision graph, and that they're all
719
1236
present in the repository.
721
1238
Callers will typically also want to check the repository.
1240
:param refs: Calculated refs for this branch as specified by
1241
branch._get_check_refs()
723
1242
:return: A BranchCheckResult.
725
mainline_parent_id = None
726
for revision_id in self.revision_history():
728
revision = self.repository.get_revision(revision_id)
729
except errors.NoSuchRevision, e:
730
raise errors.BzrCheckError("mainline revision {%s} not in repository"
732
# In general the first entry on the revision history has no parents.
733
# But it's not illegal for it to have parents listed; this can happen
734
# in imports from Arch when the parents weren't reachable.
735
if mainline_parent_id is not None:
736
if mainline_parent_id not in revision.parent_ids:
737
raise errors.BzrCheckError("previous revision {%s} not listed among "
739
% (mainline_parent_id, revision_id))
740
mainline_parent_id = revision_id
741
return BranchCheckResult(self)
1244
result = BranchCheckResult(self)
1245
last_revno, last_revision_id = self.last_revision_info()
1246
actual_revno = refs[('lefthand-distance', last_revision_id)]
1247
if actual_revno != last_revno:
1248
result.errors.append(errors.BzrCheckError(
1249
'revno does not match len(mainline) %s != %s' % (
1250
last_revno, actual_revno)))
1251
# TODO: We should probably also check that self.revision_history
1252
# matches the repository for older branch formats.
1253
# If looking for the code that cross-checks repository parents against
1254
# the iter_reverse_revision_history output, that is now a repository
743
1258
def _get_checkout_format(self):
744
1259
"""Return the most suitable metadir for a checkout of this branch.
791
1338
basis_tree.unlock()
794
def reference_parent(self, file_id, path):
1342
def reconcile(self, thorough=True):
1343
"""Make sure the data stored in this branch is consistent."""
1344
from bzrlib.reconcile import BranchReconciler
1345
reconciler = BranchReconciler(self, thorough=thorough)
1346
reconciler.reconcile()
1349
def reference_parent(self, file_id, path, possible_transports=None):
795
1350
"""Return the parent branch for a tree-reference file_id
796
1351
:param file_id: The file_id of the tree reference
797
1352
:param path: The path of the file_id in the tree
798
1353
:return: A branch associated with the file_id
800
1355
# FIXME should provide multiple branches, based on config
801
return Branch.open(self.bzrdir.root_transport.clone(path).base)
1356
return Branch.open(self.bzrdir.root_transport.clone(path).base,
1357
possible_transports=possible_transports)
803
1359
def supports_tags(self):
804
1360
return self._format.supports_tags()
1362
def _check_if_descendant_or_diverged(self, revision_a, revision_b, graph,
1364
"""Ensure that revision_b is a descendant of revision_a.
1366
This is a helper function for update_revisions.
1368
:raises: DivergedBranches if revision_b has diverged from revision_a.
1369
:returns: True if revision_b is a descendant of revision_a.
1371
relation = self._revision_relations(revision_a, revision_b, graph)
1372
if relation == 'b_descends_from_a':
1374
elif relation == 'diverged':
1375
raise errors.DivergedBranches(self, other_branch)
1376
elif relation == 'a_descends_from_b':
1379
raise AssertionError("invalid relation: %r" % (relation,))
1381
def _revision_relations(self, revision_a, revision_b, graph):
1382
"""Determine the relationship between two revisions.
1384
:returns: One of: 'a_descends_from_b', 'b_descends_from_a', 'diverged'
1386
heads = graph.heads([revision_a, revision_b])
1387
if heads == set([revision_b]):
1388
return 'b_descends_from_a'
1389
elif heads == set([revision_a, revision_b]):
1390
# These branches have diverged
1392
elif heads == set([revision_a]):
1393
return 'a_descends_from_b'
1395
raise AssertionError("invalid heads: %r" % (heads,))
807
1398
class BranchFormat(object):
808
1399
"""An encapsulation of the initialization and open routines for a format.
911
1527
"""Is this format supported?
913
1529
Supported formats can be initialized and opened.
914
Unsupported formats may not support initialization or committing or
1530
Unsupported formats may not support initialization or committing or
915
1531
some other features depending on the reason for not being supported.
919
def open(self, a_bzrdir, _found=False):
1535
def make_tags(self, branch):
1536
"""Create a tags object for branch.
1538
This method is on BranchFormat, because BranchFormats are reflected
1539
over the wire via network_name(), whereas full Branch instances require
1540
multiple VFS method calls to operate at all.
1542
The default implementation returns a disabled-tags instance.
1544
Note that it is normal for branch to be a RemoteBranch when using tags
1547
return DisabledTags(branch)
1549
def network_name(self):
1550
"""A simple byte string uniquely identifying this format for RPC calls.
1552
MetaDir branch formats use their disk format string to identify the
1553
repository over the wire. All in one formats such as bzr < 0.8, and
1554
foreign formats like svn/git and hg should use some marker which is
1555
unique and immutable.
1557
raise NotImplementedError(self.network_name)
1559
def open(self, a_bzrdir, _found=False, ignore_fallbacks=False):
920
1560
"""Return the branch object for a_bzrdir
922
_found is a private parameter, do not use it. It is used to indicate
923
if format probing has already be done.
1562
:param a_bzrdir: A BzrDir that contains a branch.
1563
:param _found: a private parameter, do not use it. It is used to
1564
indicate if format probing has already be done.
1565
:param ignore_fallbacks: when set, no fallback branches will be opened
1566
(if there are any). Default is to open fallbacks.
925
1568
raise NotImplementedError(self.open)
928
1571
def register_format(klass, format):
1572
"""Register a metadir format."""
929
1573
klass._formats[format.get_format_string()] = format
1574
# Metadir formats have a network name of their format string, and get
1575
# registered as class factories.
1576
network_format_registry.register(format.get_format_string(), format.__class__)
932
1579
def set_default_format(klass, format):
933
1580
klass._default_format = format
1582
def supports_set_append_revisions_only(self):
1583
"""True if this format supports set_append_revisions_only."""
1586
def supports_stacking(self):
1587
"""True if this format records a stacked-on branch."""
936
1591
def unregister_format(klass, format):
937
assert klass._formats[format.get_format_string()] is format
938
1592
del klass._formats[format.get_format_string()]
940
1594
def __str__(self):
941
return self.get_format_string().rstrip()
1595
return self.get_format_description().rstrip()
943
1597
def supports_tags(self):
944
1598
"""True if this format supports tags stored in the branch"""
945
1599
return False # by default
947
# XXX: Probably doesn't really belong here -- mbp 20070212
948
def _initialize_control_files(self, a_bzrdir, utf8_files, lock_filename,
950
branch_transport = a_bzrdir.get_branch_transport(self)
951
control_files = lockable_files.LockableFiles(branch_transport,
952
lock_filename, lock_class)
953
control_files.create_lock()
954
control_files.lock_write()
956
for filename, content in utf8_files:
957
control_files.put_utf8(filename, content)
959
control_files.unlock()
962
1602
class BranchHooks(Hooks):
963
1603
"""A dictionary mapping hook name to a list of callables for branch hooks.
965
1605
e.g. ['set_rh'] Is the list of items to be called when the
966
1606
set_revision_history function is invoked.
975
1615
Hooks.__init__(self)
976
# Introduced in 0.15:
977
# invoked whenever the revision history has been set
978
# with set_revision_history. The api signature is
979
# (branch, revision_history), and the branch will
982
# invoked after a push operation completes.
983
# the api signature is
985
# containing the members
986
# (source, local, master, old_revno, old_revid, new_revno, new_revid)
987
# where local is the local target branch or None, master is the target
988
# master branch, and the rest should be self explanatory. The source
989
# is read locked and the target branches write locked. Source will
990
# be the local low-latency branch.
991
self['post_push'] = []
992
# invoked after a pull operation completes.
993
# the api signature is
995
# containing the members
996
# (source, local, master, old_revno, old_revid, new_revno, new_revid)
997
# where local is the local branch or None, master is the target
998
# master branch, and the rest should be self explanatory. The source
999
# is read locked and the target branches write locked. The local
1000
# branch is the low-latency branch.
1001
self['post_pull'] = []
1002
# invoked after a commit operation completes.
1003
# the api signature is
1004
# (local, master, old_revno, old_revid, new_revno, new_revid)
1005
# old_revid is NULL_REVISION for the first commit to a branch.
1006
self['post_commit'] = []
1007
# invoked after a uncommit operation completes.
1008
# the api signature is
1009
# (local, master, old_revno, old_revid, new_revno, new_revid) where
1010
# local is the local branch or None, master is the target branch,
1011
# and an empty branch recieves new_revno of 0, new_revid of None.
1012
self['post_uncommit'] = []
1616
self.create_hook(HookPoint('set_rh',
1617
"Invoked whenever the revision history has been set via "
1618
"set_revision_history. The api signature is (branch, "
1619
"revision_history), and the branch will be write-locked. "
1620
"The set_rh hook can be expensive for bzr to trigger, a better "
1621
"hook to use is Branch.post_change_branch_tip.", (0, 15), None))
1622
self.create_hook(HookPoint('open',
1623
"Called with the Branch object that has been opened after a "
1624
"branch is opened.", (1, 8), None))
1625
self.create_hook(HookPoint('post_push',
1626
"Called after a push operation completes. post_push is called "
1627
"with a bzrlib.branch.BranchPushResult object and only runs in the "
1628
"bzr client.", (0, 15), None))
1629
self.create_hook(HookPoint('post_pull',
1630
"Called after a pull operation completes. post_pull is called "
1631
"with a bzrlib.branch.PullResult object and only runs in the "
1632
"bzr client.", (0, 15), None))
1633
self.create_hook(HookPoint('pre_commit',
1634
"Called after a commit is calculated but before it is is "
1635
"completed. pre_commit is called with (local, master, old_revno, "
1636
"old_revid, future_revno, future_revid, tree_delta, future_tree"
1637
"). old_revid is NULL_REVISION for the first commit to a branch, "
1638
"tree_delta is a TreeDelta object describing changes from the "
1639
"basis revision. hooks MUST NOT modify this delta. "
1640
" future_tree is an in-memory tree obtained from "
1641
"CommitBuilder.revision_tree() and hooks MUST NOT modify this "
1642
"tree.", (0,91), None))
1643
self.create_hook(HookPoint('post_commit',
1644
"Called in the bzr client after a commit has completed. "
1645
"post_commit is called with (local, master, old_revno, old_revid, "
1646
"new_revno, new_revid). old_revid is NULL_REVISION for the first "
1647
"commit to a branch.", (0, 15), None))
1648
self.create_hook(HookPoint('post_uncommit',
1649
"Called in the bzr client after an uncommit completes. "
1650
"post_uncommit is called with (local, master, old_revno, "
1651
"old_revid, new_revno, new_revid) where local is the local branch "
1652
"or None, master is the target branch, and an empty branch "
1653
"receives new_revno of 0, new_revid of None.", (0, 15), None))
1654
self.create_hook(HookPoint('pre_change_branch_tip',
1655
"Called in bzr client and server before a change to the tip of a "
1656
"branch is made. pre_change_branch_tip is called with a "
1657
"bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1658
"commit, uncommit will all trigger this hook.", (1, 6), None))
1659
self.create_hook(HookPoint('post_change_branch_tip',
1660
"Called in bzr client and server after a change to the tip of a "
1661
"branch is made. post_change_branch_tip is called with a "
1662
"bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1663
"commit, uncommit will all trigger this hook.", (1, 4), None))
1664
self.create_hook(HookPoint('transform_fallback_location',
1665
"Called when a stacked branch is activating its fallback "
1666
"locations. transform_fallback_location is called with (branch, "
1667
"url), and should return a new url. Returning the same url "
1668
"allows it to be used as-is, returning a different one can be "
1669
"used to cause the branch to stack on a closer copy of that "
1670
"fallback_location. Note that the branch cannot have history "
1671
"accessing methods called on it during this hook because the "
1672
"fallback locations have not been activated. When there are "
1673
"multiple hooks installed for transform_fallback_location, "
1674
"all are called with the url returned from the previous hook."
1675
"The order is however undefined.", (1, 9), None))
1015
1678
# install the default hooks into the Branch class.
1016
1679
Branch.hooks = BranchHooks()
1682
class ChangeBranchTipParams(object):
1683
"""Object holding parameters passed to *_change_branch_tip hooks.
1685
There are 5 fields that hooks may wish to access:
1687
:ivar branch: the branch being changed
1688
:ivar old_revno: revision number before the change
1689
:ivar new_revno: revision number after the change
1690
:ivar old_revid: revision id before the change
1691
:ivar new_revid: revision id after the change
1693
The revid fields are strings. The revno fields are integers.
1696
def __init__(self, branch, old_revno, new_revno, old_revid, new_revid):
1697
"""Create a group of ChangeBranchTip parameters.
1699
:param branch: The branch being changed.
1700
:param old_revno: Revision number before the change.
1701
:param new_revno: Revision number after the change.
1702
:param old_revid: Tip revision id before the change.
1703
:param new_revid: Tip revision id after the change.
1705
self.branch = branch
1706
self.old_revno = old_revno
1707
self.new_revno = new_revno
1708
self.old_revid = old_revid
1709
self.new_revid = new_revid
1711
def __eq__(self, other):
1712
return self.__dict__ == other.__dict__
1715
return "<%s of %s from (%s, %s) to (%s, %s)>" % (
1716
self.__class__.__name__, self.branch,
1717
self.old_revno, self.old_revid, self.new_revno, self.new_revid)
1019
1720
class BzrBranchFormat4(BranchFormat):
1020
1721
"""Bzr branch format 4.
1133
1861
def initialize(self, a_bzrdir):
1134
1862
"""Create a branch of this format in a_bzrdir."""
1135
1863
utf8_files = [('last-revision', '0 null:\n'),
1136
('branch-name', ''),
1137
('branch.conf', ''),
1140
return self._initialize_helper(a_bzrdir, utf8_files)
1142
def open(self, a_bzrdir, _found=False):
1143
"""Return the branch object for a_bzrdir
1145
_found is a private parameter, do not use it. It is used to indicate
1146
if format probing has already be done.
1149
format = BranchFormat.find_format(a_bzrdir)
1150
assert format.__class__ == self.__class__
1151
transport = a_bzrdir.get_branch_transport(None)
1152
control_files = lockable_files.LockableFiles(transport, 'lock',
1154
return BzrBranch6(_format=self,
1155
_control_files=control_files,
1157
_repository=a_bzrdir.find_repository())
1159
def supports_tags(self):
1864
('branch.conf', ''),
1867
return self._initialize_helper(a_bzrdir, utf8_files)
1869
def make_tags(self, branch):
1870
"""See bzrlib.branch.BranchFormat.make_tags()."""
1871
return BasicTags(branch)
1873
def supports_set_append_revisions_only(self):
1877
class BzrBranchFormat8(BranchFormatMetadir):
1878
"""Metadir format supporting storing locations of subtree branches."""
1880
def _branch_class(self):
1883
def get_format_string(self):
1884
"""See BranchFormat.get_format_string()."""
1885
return "Bazaar Branch Format 8 (needs bzr 1.15)\n"
1887
def get_format_description(self):
1888
"""See BranchFormat.get_format_description()."""
1889
return "Branch format 8"
1891
def initialize(self, a_bzrdir):
1892
"""Create a branch of this format in a_bzrdir."""
1893
utf8_files = [('last-revision', '0 null:\n'),
1894
('branch.conf', ''),
1898
return self._initialize_helper(a_bzrdir, utf8_files)
1901
super(BzrBranchFormat8, self).__init__()
1902
self._matchingbzrdir.repository_format = \
1903
RepositoryFormatKnitPack5RichRoot()
1905
def make_tags(self, branch):
1906
"""See bzrlib.branch.BranchFormat.make_tags()."""
1907
return BasicTags(branch)
1909
def supports_set_append_revisions_only(self):
1912
def supports_stacking(self):
1915
supports_reference_locations = True
1918
class BzrBranchFormat7(BzrBranchFormat8):
1919
"""Branch format with last-revision, tags, and a stacked location pointer.
1921
The stacked location pointer is passed down to the repository and requires
1922
a repository format with supports_external_lookups = True.
1924
This format was introduced in bzr 1.6.
1927
def initialize(self, a_bzrdir):
1928
"""Create a branch of this format in a_bzrdir."""
1929
utf8_files = [('last-revision', '0 null:\n'),
1930
('branch.conf', ''),
1933
return self._initialize_helper(a_bzrdir, utf8_files)
1935
def _branch_class(self):
1938
def get_format_string(self):
1939
"""See BranchFormat.get_format_string()."""
1940
return "Bazaar Branch Format 7 (needs bzr 1.6)\n"
1942
def get_format_description(self):
1943
"""See BranchFormat.get_format_description()."""
1944
return "Branch format 7"
1946
def supports_set_append_revisions_only(self):
1949
supports_reference_locations = False
1163
1952
class BranchReferenceFormat(BranchFormat):
1347
2186
This performs the actual writing to disk.
1348
2187
It is intended to be called by BzrBranch5.set_revision_history."""
1349
self.control_files.put_bytes(
1350
'revision-history', '\n'.join(history))
2188
self._transport.put_bytes(
2189
'revision-history', '\n'.join(history),
2190
mode=self.bzrdir._get_file_mode())
1352
2192
@needs_write_lock
1353
2193
def set_revision_history(self, rev_history):
1354
2194
"""See Branch.set_revision_history."""
1355
rev_history = [osutils.safe_revision_id(r) for r in rev_history]
1356
self._clear_cached_state()
2195
if 'evil' in debug.debug_flags:
2196
mutter_callsite(3, "set_revision_history scales with history.")
2197
check_not_reserved_id = _mod_revision.check_not_reserved_id
2198
for rev_id in rev_history:
2199
check_not_reserved_id(rev_id)
2200
if Branch.hooks['post_change_branch_tip']:
2201
# Don't calculate the last_revision_info() if there are no hooks
2203
old_revno, old_revid = self.last_revision_info()
2204
if len(rev_history) == 0:
2205
revid = _mod_revision.NULL_REVISION
2207
revid = rev_history[-1]
2208
self._run_pre_change_branch_tip_hooks(len(rev_history), revid)
1357
2209
self._write_revision_history(rev_history)
2210
self._clear_cached_state()
1358
2211
self._cache_revision_history(rev_history)
1359
2212
for hook in Branch.hooks['set_rh']:
1360
2213
hook(self, rev_history)
2214
if Branch.hooks['post_change_branch_tip']:
2215
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2217
def _synchronize_history(self, destination, revision_id):
2218
"""Synchronize last revision and revision history between branches.
2220
This version is most efficient when the destination is also a
2221
BzrBranch5, but works for BzrBranch6 as long as the revision
2222
history is the true lefthand parent history, and all of the revisions
2223
are in the destination's repository. If not, set_revision_history
2226
:param destination: The branch to copy the history into
2227
:param revision_id: The revision-id to truncate history at. May
2228
be None to copy complete history.
2230
if not isinstance(destination._format, BzrBranchFormat5):
2231
super(BzrBranch, self)._synchronize_history(
2232
destination, revision_id)
2234
if revision_id == _mod_revision.NULL_REVISION:
2237
new_history = self.revision_history()
2238
if revision_id is not None and new_history != []:
2240
new_history = new_history[:new_history.index(revision_id) + 1]
2242
rev = self.repository.get_revision(revision_id)
2243
new_history = rev.get_history(self.repository)[1:]
2244
destination.set_revision_history(new_history)
1362
2246
@needs_write_lock
1363
2247
def set_last_revision_info(self, revno, revision_id):
1415
2282
:param other_branch: The other branch that DivergedBranches should
1416
2283
raise with respect to.
1418
revision_id = osutils.safe_revision_id(revision_id)
1419
2285
self.set_revision_history(self._lefthand_history(revision_id,
1420
2286
last_rev, other_branch))
1423
def update_revisions(self, other, stop_revision=None):
1424
"""See Branch.update_revisions."""
1427
if stop_revision is None:
1428
stop_revision = other.last_revision()
1429
if stop_revision is None:
1430
# if there are no commits, we're done.
1433
stop_revision = osutils.safe_revision_id(stop_revision)
1434
# whats the current last revision, before we fetch [and change it
1436
last_rev = _mod_revision.ensure_null(self.last_revision())
1437
# we fetch here regardless of whether we need to so that we pickup
1439
self.fetch(other, stop_revision)
1440
if self.repository.get_graph().is_ancestor(stop_revision,
1443
self.generate_revision_history(stop_revision, last_rev=last_rev,
1448
2288
def basis_tree(self):
1449
2289
"""See Branch.basis_tree."""
1450
2290
return self.repository.revision_tree(self.last_revision())
1453
def pull(self, source, overwrite=False, stop_revision=None,
1454
_hook_master=None, run_hooks=True):
1457
:param _hook_master: Private parameter - set the branch to
1458
be supplied as the master to push hooks.
1459
:param run_hooks: Private parameter - if false, this branch
1460
is being called because it's the master of the primary branch,
1461
so it should not run its hooks.
1463
result = PullResult()
1464
result.source_branch = source
1465
result.target_branch = self
1468
result.old_revno, result.old_revid = self.last_revision_info()
1470
self.update_revisions(source, stop_revision)
1471
except DivergedBranches:
1475
if stop_revision is None:
1476
stop_revision = source.last_revision()
1477
self.generate_revision_history(stop_revision)
1478
result.tag_conflicts = source.tags.merge_to(self.tags)
1479
result.new_revno, result.new_revid = self.last_revision_info()
1481
result.master_branch = _hook_master
1482
result.local_branch = self
1484
result.master_branch = self
1485
result.local_branch = None
1487
for hook in Branch.hooks['post_pull']:
1493
2292
def _get_parent_location(self):
1494
2293
_locs = ['parent', 'pull', 'x-pull']
1495
2294
for l in _locs:
1497
return self.control_files.get(l).read().strip('\n')
2296
return self._transport.get_bytes(l).strip('\n')
2297
except errors.NoSuchFile:
1503
def push(self, target, overwrite=False, stop_revision=None,
1504
_override_hook_source_branch=None):
1507
This is the basic concrete implementation of push()
1509
:param _override_hook_source_branch: If specified, run
1510
the hooks passing this Branch as the source, rather than self.
1511
This is for use of RemoteBranch, where push is delegated to the
1512
underlying vfs-based Branch.
1514
# TODO: Public option to disable running hooks - should be trivial but
1518
result = self._push_with_bound_branches(target, overwrite,
1520
_override_hook_source_branch=_override_hook_source_branch)
1525
def _push_with_bound_branches(self, target, overwrite,
1527
_override_hook_source_branch=None):
1528
"""Push from self into target, and into target's master if any.
1530
This is on the base BzrBranch class even though it doesn't support
1531
bound branches because the *target* might be bound.
1534
if _override_hook_source_branch:
1535
result.source_branch = _override_hook_source_branch
1536
for hook in Branch.hooks['post_push']:
1539
bound_location = target.get_bound_location()
1540
if bound_location and target.base != bound_location:
1541
# there is a master branch.
1543
# XXX: Why the second check? Is it even supported for a branch to
1544
# be bound to itself? -- mbp 20070507
1545
master_branch = target.get_master_branch()
1546
master_branch.lock_write()
1548
# push into the master from this branch.
1549
self._basic_push(master_branch, overwrite, stop_revision)
1550
# and push into the target branch from this. Note that we push from
1551
# this branch again, because its considered the highest bandwidth
1553
result = self._basic_push(target, overwrite, stop_revision)
1554
result.master_branch = master_branch
1555
result.local_branch = target
1559
master_branch.unlock()
1562
result = self._basic_push(target, overwrite, stop_revision)
1563
# TODO: Why set master_branch and local_branch if there's no
1564
# binding? Maybe cleaner to just leave them unset? -- mbp
1566
result.master_branch = target
1567
result.local_branch = None
1571
2301
def _basic_push(self, target, overwrite, stop_revision):
1572
2302
"""Basic implementation of push without bound branches or hooks.
1574
Must be called with self read locked and target write locked.
2304
Must be called with source read locked and target write locked.
1576
result = PushResult()
2306
result = BranchPushResult()
1577
2307
result.source_branch = self
1578
2308
result.target_branch = target
1579
2309
result.old_revno, result.old_revid = target.last_revision_info()
1581
target.update_revisions(self, stop_revision)
1582
except DivergedBranches:
1586
target.set_revision_history(self.revision_history())
1587
result.tag_conflicts = self.tags.merge_to(target.tags)
2310
self.update_references(target)
2311
if result.old_revid != self.last_revision():
2312
# We assume that during 'push' this repository is closer than
2314
graph = self.repository.get_graph(target.repository)
2315
target.update_revisions(self, stop_revision,
2316
overwrite=overwrite, graph=graph)
2317
if self._push_should_merge_tags():
2318
result.tag_conflicts = self.tags.merge_to(target.tags,
1588
2320
result.new_revno, result.new_revid = target.last_revision_info()
1591
def get_parent(self):
1592
"""See Branch.get_parent."""
1594
assert self.base[-1] == '/'
1595
parent = self._get_parent_location()
1598
# This is an old-format absolute path to a local branch
1599
# turn it into a url
1600
if parent.startswith('/'):
1601
parent = urlutils.local_path_to_url(parent.decode('utf8'))
1603
return urlutils.join(self.base[:-1], parent)
1604
except errors.InvalidURLJoin, e:
1605
raise errors.InaccessibleParent(parent, self.base)
2323
def get_stacked_on_url(self):
2324
raise errors.UnstackableBranchFormat(self._format, self.base)
1607
2326
def set_push_location(self, location):
1608
2327
"""See Branch.set_push_location."""
1610
2329
'push_location', location,
1611
2330
store=_mod_config.STORE_LOCATION_NORECURSE)
1614
def set_parent(self, url):
1615
"""See Branch.set_parent."""
1616
# TODO: Maybe delete old location files?
1617
# URLs should never be unicode, even on the local fs,
1618
# FIXUP this and get_parent in a future branch format bump:
1619
# read and rewrite the file, and have the new format code read
1620
# using .get not .get_utf8. RBC 20060125
1622
if isinstance(url, unicode):
1624
url = url.encode('ascii')
1625
except UnicodeEncodeError:
1626
raise errors.InvalidURL(url,
1627
"Urls must be 7-bit ascii, "
1628
"use bzrlib.urlutils.escape")
1629
url = urlutils.relative_url(self.base, url)
1630
self._set_parent_location(url)
1632
2332
def _set_parent_location(self, url):
1633
2333
if url is None:
1634
self.control_files._transport.delete('parent')
2334
self._transport.delete('parent')
1636
assert isinstance(url, str)
1637
self.control_files.put_bytes('parent', url + '\n')
2336
self._transport.put_bytes('parent', url + '\n',
2337
mode=self.bzrdir._get_file_mode())
1640
2340
class BzrBranch5(BzrBranch):
1641
"""A format 5 branch. This supports new features over plan branches.
2341
"""A format 5 branch. This supports new features over plain branches.
1643
2343
It has support for a master_branch which is the data for bound branches.
1651
super(BzrBranch5, self).__init__(_format=_format,
1652
_control_files=_control_files,
1654
_repository=_repository)
1657
def pull(self, source, overwrite=False, stop_revision=None,
1659
"""Pull from source into self, updating my master if any.
1661
:param run_hooks: Private parameter - if false, this branch
1662
is being called because it's the master of the primary branch,
1663
so it should not run its hooks.
1665
bound_location = self.get_bound_location()
1666
master_branch = None
1667
if bound_location and source.base != bound_location:
1668
# not pulling from master, so we need to update master.
1669
master_branch = self.get_master_branch()
1670
master_branch.lock_write()
1673
# pull from source into master.
1674
master_branch.pull(source, overwrite, stop_revision,
1676
return super(BzrBranch5, self).pull(source, overwrite,
1677
stop_revision, _hook_master=master_branch,
1678
run_hooks=run_hooks)
1681
master_branch.unlock()
1683
2346
def get_bound_location(self):
1685
return self.control_files.get_utf8('bound').read()[:-1]
2348
return self._transport.get_bytes('bound')[:-1]
1686
2349
except errors.NoSuchFile:
1689
2352
@needs_read_lock
1690
def get_master_branch(self):
2353
def get_master_branch(self, possible_transports=None):
1691
2354
"""Return the branch we are bound to.
1693
2356
:return: Either a Branch, or None
1695
2358
This could memoise the branch, but if thats done
1789
class BzrBranchExperimental(BzrBranch5):
1790
"""Bzr experimental branch format
1793
- a revision-history file.
1795
- a lock dir guarding the branch itself
1796
- all of this stored in a branch/ subdirectory
1797
- works with shared repositories.
1798
- a tag dictionary in the branch
1800
This format is new in bzr 0.15, but shouldn't be used for real data,
1803
This class acts as it's own BranchFormat.
1806
_matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1809
def get_format_string(cls):
1810
"""See BranchFormat.get_format_string()."""
1811
return "Bazaar-NG branch format experimental\n"
1814
def get_format_description(cls):
1815
"""See BranchFormat.get_format_description()."""
1816
return "Experimental branch format"
1819
def get_reference(cls, a_bzrdir):
1820
"""Get the target reference of the branch in a_bzrdir.
1822
format probing must have been completed before calling
1823
this method - it is assumed that the format of the branch
1824
in a_bzrdir is correct.
1826
:param a_bzrdir: The bzrdir to get the branch data from.
1827
:return: None if the branch is not a reference branch.
1832
def _initialize_control_files(cls, a_bzrdir, utf8_files, lock_filename,
1834
branch_transport = a_bzrdir.get_branch_transport(cls)
1835
control_files = lockable_files.LockableFiles(branch_transport,
1836
lock_filename, lock_class)
1837
control_files.create_lock()
1838
control_files.lock_write()
2438
class BzrBranch8(BzrBranch5):
2439
"""A branch that stores tree-reference locations."""
2441
def _open_hook(self):
2442
if self._ignore_fallbacks:
1840
for filename, content in utf8_files:
1841
control_files.put_utf8(filename, content)
1843
control_files.unlock()
1846
def initialize(cls, a_bzrdir):
1847
"""Create a branch of this format in a_bzrdir."""
1848
utf8_files = [('format', cls.get_format_string()),
1849
('revision-history', ''),
1850
('branch-name', ''),
1853
cls._initialize_control_files(a_bzrdir, utf8_files,
1854
'lock', lockdir.LockDir)
1855
return cls.open(a_bzrdir, _found=True)
1858
def open(cls, a_bzrdir, _found=False):
1859
"""Return the branch object for a_bzrdir
1861
_found is a private parameter, do not use it. It is used to indicate
1862
if format probing has already be done.
1865
format = BranchFormat.find_format(a_bzrdir)
1866
assert format.__class__ == cls
1867
transport = a_bzrdir.get_branch_transport(None)
1868
control_files = lockable_files.LockableFiles(transport, 'lock',
1870
return cls(_format=cls,
1871
_control_files=control_files,
1873
_repository=a_bzrdir.find_repository())
1876
def is_supported(cls):
1879
def _make_tags(self):
1880
return BasicTags(self)
1883
def supports_tags(cls):
1887
BranchFormat.register_format(BzrBranchExperimental)
1890
class BzrBranch6(BzrBranch5):
1893
def last_revision_info(self):
1894
revision_string = self.control_files.get('last-revision').read()
2445
url = self.get_stacked_on_url()
2446
except (errors.UnstackableRepositoryFormat, errors.NotStacked,
2447
errors.UnstackableBranchFormat):
2450
for hook in Branch.hooks['transform_fallback_location']:
2451
url = hook(self, url)
2453
hook_name = Branch.hooks.get_hook_name(hook)
2454
raise AssertionError(
2455
"'transform_fallback_location' hook %s returned "
2456
"None, not a URL." % hook_name)
2457
self._activate_fallback_location(url)
2459
def __init__(self, *args, **kwargs):
2460
self._ignore_fallbacks = kwargs.get('ignore_fallbacks', False)
2461
super(BzrBranch8, self).__init__(*args, **kwargs)
2462
self._last_revision_info_cache = None
2463
self._reference_info = None
2465
def _clear_cached_state(self):
2466
super(BzrBranch8, self)._clear_cached_state()
2467
self._last_revision_info_cache = None
2468
self._reference_info = None
2470
def _last_revision_info(self):
2471
revision_string = self._transport.get_bytes('last-revision')
1895
2472
revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
1896
2473
revision_id = cache_utf8.get_cached_utf8(revision_id)
1897
2474
revno = int(revno)
1898
2475
return revno, revision_id
1900
def last_revision(self):
1901
"""Return last revision id, or None"""
1902
revision_id = self.last_revision_info()[1]
1905
2477
def _write_last_revision_info(self, revno, revision_id):
1906
2478
"""Simply write out the revision id, with no checks.
1965
2552
"""Set the parent branch"""
1966
2553
return self._get_config_location('parent_location')
2556
def _set_all_reference_info(self, info_dict):
2557
"""Replace all reference info stored in a branch.
2559
:param info_dict: A dict of {file_id: (tree_path, branch_location)}
2562
writer = rio.RioWriter(s)
2563
for key, (tree_path, branch_location) in info_dict.iteritems():
2564
stanza = rio.Stanza(file_id=key, tree_path=tree_path,
2565
branch_location=branch_location)
2566
writer.write_stanza(stanza)
2567
self._transport.put_bytes('references', s.getvalue())
2568
self._reference_info = info_dict
2571
def _get_all_reference_info(self):
2572
"""Return all the reference info stored in a branch.
2574
:return: A dict of {file_id: (tree_path, branch_location)}
2576
if self._reference_info is not None:
2577
return self._reference_info
2578
rio_file = self._transport.get('references')
2580
stanzas = rio.read_stanzas(rio_file)
2581
info_dict = dict((s['file_id'], (s['tree_path'],
2582
s['branch_location'])) for s in stanzas)
2585
self._reference_info = info_dict
2588
def set_reference_info(self, file_id, tree_path, branch_location):
2589
"""Set the branch location to use for a tree reference.
2591
:param file_id: The file-id of the tree reference.
2592
:param tree_path: The path of the tree reference in the tree.
2593
:param branch_location: The location of the branch to retrieve tree
2596
info_dict = self._get_all_reference_info()
2597
info_dict[file_id] = (tree_path, branch_location)
2598
if None in (tree_path, branch_location):
2599
if tree_path is not None:
2600
raise ValueError('tree_path must be None when branch_location'
2602
if branch_location is not None:
2603
raise ValueError('branch_location must be None when tree_path'
2605
del info_dict[file_id]
2606
self._set_all_reference_info(info_dict)
2608
def get_reference_info(self, file_id):
2609
"""Get the tree_path and branch_location for a tree reference.
2611
:return: a tuple of (tree_path, branch_location)
2613
return self._get_all_reference_info().get(file_id, (None, None))
2615
def reference_parent(self, file_id, path, possible_transports=None):
2616
"""Return the parent branch for a tree-reference file_id.
2618
:param file_id: The file_id of the tree reference
2619
:param path: The path of the file_id in the tree
2620
:return: A branch associated with the file_id
2622
branch_location = self.get_reference_info(file_id)[1]
2623
if branch_location is None:
2624
return Branch.reference_parent(self, file_id, path,
2625
possible_transports)
2626
branch_location = urlutils.join(self.base, branch_location)
2627
return Branch.open(branch_location,
2628
possible_transports=possible_transports)
1968
2630
def set_push_location(self, location):
1969
2631
"""See Branch.set_push_location."""
1970
2632
self._set_config_location('push_location', location)
2003
2665
"""See Branch.get_old_bound_location"""
2004
2666
return self._get_bound_location(False)
2006
def set_append_revisions_only(self, enabled):
2011
self.get_config().set_user_option('append_revisions_only', value,
2668
def get_stacked_on_url(self):
2669
# you can always ask for the URL; but you might not be able to use it
2670
# if the repo can't support stacking.
2671
## self._check_stackable_repo()
2672
stacked_url = self._get_config_location('stacked_on_location')
2673
if stacked_url is None:
2674
raise errors.NotStacked(self)
2014
2677
def _get_append_revisions_only(self):
2015
2678
value = self.get_config().get_user_option('append_revisions_only')
2016
2679
return value == 'True'
2018
def _synchronize_history(self, destination, revision_id):
2019
"""Synchronize last revision and revision history between branches.
2021
This version is most efficient when the destination is also a
2022
BzrBranch6, but works for BzrBranch5, as long as the destination's
2023
repository contains all the lefthand ancestors of the intended
2024
last_revision. If not, set_last_revision_info will fail.
2026
:param destination: The branch to copy the history into
2027
:param revision_id: The revision-id to truncate history at. May
2028
be None to copy complete history.
2030
source_revno, source_revision_id = self.last_revision_info()
2031
if revision_id is None:
2032
revno, revision_id = source_revno, source_revision_id
2033
elif source_revision_id == revision_id:
2034
# we know the revno without needing to walk all of history
2035
revno = source_revno
2682
def generate_revision_history(self, revision_id, last_rev=None,
2684
"""See BzrBranch5.generate_revision_history"""
2685
history = self._lefthand_history(revision_id, last_rev, other_branch)
2686
revno = len(history)
2687
self.set_last_revision_info(revno, revision_id)
2690
def get_rev_id(self, revno, history=None):
2691
"""Find the revision id of the specified revno."""
2693
return _mod_revision.NULL_REVISION
2695
last_revno, last_revision_id = self.last_revision_info()
2696
if revno <= 0 or revno > last_revno:
2697
raise errors.NoSuchRevision(self, revno)
2699
if history is not None:
2700
return history[revno - 1]
2702
index = last_revno - revno
2703
if len(self._partial_revision_history_cache) <= index:
2704
self._extend_partial_history(stop_index=index)
2705
if len(self._partial_revision_history_cache) > index:
2706
return self._partial_revision_history_cache[index]
2037
# To figure out the revno for a random revision, we need to build
2038
# the revision history, and count its length.
2039
# We don't care about the order, just how long it is.
2040
# Alternatively, we could start at the current location, and count
2041
# backwards. But there is no guarantee that we will find it since
2042
# it may be a merged revision.
2043
revno = len(list(self.repository.iter_reverse_revision_history(
2045
destination.set_last_revision_info(revno, revision_id)
2047
def _make_tags(self):
2048
return BasicTags(self)
2708
raise errors.NoSuchRevision(self, revno)
2711
def revision_id_to_revno(self, revision_id):
2712
"""Given a revision id, return its revno"""
2713
if _mod_revision.is_null(revision_id):
2716
index = self._partial_revision_history_cache.index(revision_id)
2718
self._extend_partial_history(stop_revision=revision_id)
2719
index = len(self._partial_revision_history_cache) - 1
2720
if self._partial_revision_history_cache[index] != revision_id:
2721
raise errors.NoSuchRevision(self, revision_id)
2722
return self.revno() - index
2725
class BzrBranch7(BzrBranch8):
2726
"""A branch with support for a fallback repository."""
2728
def set_reference_info(self, file_id, tree_path, branch_location):
2729
Branch.set_reference_info(self, file_id, tree_path, branch_location)
2731
def get_reference_info(self, file_id):
2732
Branch.get_reference_info(self, file_id)
2734
def reference_parent(self, file_id, path, possible_transports=None):
2735
return Branch.reference_parent(self, file_id, path,
2736
possible_transports)
2739
class BzrBranch6(BzrBranch7):
2740
"""See BzrBranchFormat6 for the capabilities of this branch.
2742
This subclass of BzrBranch7 disables the new features BzrBranch7 added,
2746
def get_stacked_on_url(self):
2747
raise errors.UnstackableBranchFormat(self._format, self.base)
2051
2750
######################################################################
2149
2861
new_branch.tags._set_tag_dict({})
2151
2863
# Copying done; now update target format
2152
new_branch.control_files.put_utf8('format',
2153
format.get_format_string())
2864
new_branch._transport.put_bytes('format',
2865
format.get_format_string(),
2866
mode=new_branch.bzrdir._get_file_mode())
2155
2868
# Clean up old files
2156
new_branch.control_files._transport.delete('revision-history')
2869
new_branch._transport.delete('revision-history')
2158
2871
branch.set_parent(None)
2872
except errors.NoSuchFile:
2161
2874
branch.set_bound_location(None)
2877
class Converter6to7(object):
2878
"""Perform an in-place upgrade of format 6 to format 7"""
2880
def convert(self, branch):
2881
format = BzrBranchFormat7()
2882
branch._set_config_location('stacked_on_location', '')
2883
# update target format
2884
branch._transport.put_bytes('format', format.get_format_string())
2887
class Converter7to8(object):
2888
"""Perform an in-place upgrade of format 6 to format 7"""
2890
def convert(self, branch):
2891
format = BzrBranchFormat8()
2892
branch._transport.put_bytes('references', '')
2893
# update target format
2894
branch._transport.put_bytes('format', format.get_format_string())
2897
def _run_with_write_locked_target(target, callable, *args, **kwargs):
2898
"""Run ``callable(*args, **kwargs)``, write-locking target for the
2901
_run_with_write_locked_target will attempt to release the lock it acquires.
2903
If an exception is raised by callable, then that exception *will* be
2904
propagated, even if the unlock attempt raises its own error. Thus
2905
_run_with_write_locked_target should be preferred to simply doing::
2909
return callable(*args, **kwargs)
2914
# This is very similar to bzrlib.decorators.needs_write_lock. Perhaps they
2915
# should share code?
2918
result = callable(*args, **kwargs)
2920
exc_info = sys.exc_info()
2924
raise exc_info[0], exc_info[1], exc_info[2]
2930
class InterBranch(InterObject):
2931
"""This class represents operations taking place between two branches.
2933
Its instances have methods like pull() and push() and contain
2934
references to the source and target repositories these operations
2935
can be carried out on.
2939
"""The available optimised InterBranch types."""
2942
def _get_branch_formats_to_test():
2943
"""Return a tuple with the Branch formats to use when testing."""
2944
raise NotImplementedError(InterBranch._get_branch_formats_to_test)
2946
def pull(self, overwrite=False, stop_revision=None,
2947
possible_transports=None, local=False):
2948
"""Mirror source into target branch.
2950
The target branch is considered to be 'local', having low latency.
2952
:returns: PullResult instance
2954
raise NotImplementedError(self.pull)
2956
def update_revisions(self, stop_revision=None, overwrite=False,
2958
"""Pull in new perfect-fit revisions.
2960
:param stop_revision: Updated until the given revision
2961
:param overwrite: Always set the branch pointer, rather than checking
2962
to see if it is a proper descendant.
2963
:param graph: A Graph object that can be used to query history
2964
information. This can be None.
2967
raise NotImplementedError(self.update_revisions)
2969
def push(self, overwrite=False, stop_revision=None,
2970
_override_hook_source_branch=None):
2971
"""Mirror the source branch into the target branch.
2973
The source branch is considered to be 'local', having low latency.
2975
raise NotImplementedError(self.push)
2978
class GenericInterBranch(InterBranch):
2979
"""InterBranch implementation that uses public Branch functions.
2983
def _get_branch_formats_to_test():
2984
return BranchFormat._default_format, BranchFormat._default_format
2986
def update_revisions(self, stop_revision=None, overwrite=False,
2988
"""See InterBranch.update_revisions()."""
2989
self.source.lock_read()
2991
other_revno, other_last_revision = self.source.last_revision_info()
2992
stop_revno = None # unknown
2993
if stop_revision is None:
2994
stop_revision = other_last_revision
2995
if _mod_revision.is_null(stop_revision):
2996
# if there are no commits, we're done.
2998
stop_revno = other_revno
3000
# what's the current last revision, before we fetch [and change it
3002
last_rev = _mod_revision.ensure_null(self.target.last_revision())
3003
# we fetch here so that we don't process data twice in the common
3004
# case of having something to pull, and so that the check for
3005
# already merged can operate on the just fetched graph, which will
3006
# be cached in memory.
3007
self.target.fetch(self.source, stop_revision)
3008
# Check to see if one is an ancestor of the other
3011
graph = self.target.repository.get_graph()
3012
if self.target._check_if_descendant_or_diverged(
3013
stop_revision, last_rev, graph, self.source):
3014
# stop_revision is a descendant of last_rev, but we aren't
3015
# overwriting, so we're done.
3017
if stop_revno is None:
3019
graph = self.target.repository.get_graph()
3020
this_revno, this_last_revision = \
3021
self.target.last_revision_info()
3022
stop_revno = graph.find_distance_to_null(stop_revision,
3023
[(other_last_revision, other_revno),
3024
(this_last_revision, this_revno)])
3025
self.target.set_last_revision_info(stop_revno, stop_revision)
3027
self.source.unlock()
3029
def pull(self, overwrite=False, stop_revision=None,
3030
possible_transports=None, _hook_master=None, run_hooks=True,
3031
_override_hook_target=None, local=False):
3034
:param _hook_master: Private parameter - set the branch to
3035
be supplied as the master to pull hooks.
3036
:param run_hooks: Private parameter - if false, this branch
3037
is being called because it's the master of the primary branch,
3038
so it should not run its hooks.
3039
:param _override_hook_target: Private parameter - set the branch to be
3040
supplied as the target_branch to pull hooks.
3041
:param local: Only update the local branch, and not the bound branch.
3043
# This type of branch can't be bound.
3045
raise errors.LocalRequiresBoundBranch()
3046
result = PullResult()
3047
result.source_branch = self.source
3048
if _override_hook_target is None:
3049
result.target_branch = self.target
3051
result.target_branch = _override_hook_target
3052
self.source.lock_read()
3054
# We assume that during 'pull' the target repository is closer than
3056
self.source.update_references(self.target)
3057
graph = self.target.repository.get_graph(self.source.repository)
3058
# TODO: Branch formats should have a flag that indicates
3059
# that revno's are expensive, and pull() should honor that flag.
3061
result.old_revno, result.old_revid = \
3062
self.target.last_revision_info()
3063
self.target.update_revisions(self.source, stop_revision,
3064
overwrite=overwrite, graph=graph)
3065
# TODO: The old revid should be specified when merging tags,
3066
# so a tags implementation that versions tags can only
3067
# pull in the most recent changes. -- JRV20090506
3068
result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
3070
result.new_revno, result.new_revid = self.target.last_revision_info()
3072
result.master_branch = _hook_master
3073
result.local_branch = result.target_branch
3075
result.master_branch = result.target_branch
3076
result.local_branch = None
3078
for hook in Branch.hooks['post_pull']:
3081
self.source.unlock()
3084
def push(self, overwrite=False, stop_revision=None,
3085
_override_hook_source_branch=None):
3086
"""See InterBranch.push.
3088
This is the basic concrete implementation of push()
3090
:param _override_hook_source_branch: If specified, run
3091
the hooks passing this Branch as the source, rather than self.
3092
This is for use of RemoteBranch, where push is delegated to the
3093
underlying vfs-based Branch.
3095
# TODO: Public option to disable running hooks - should be trivial but
3097
self.source.lock_read()
3099
return _run_with_write_locked_target(
3100
self.target, self._push_with_bound_branches, overwrite,
3102
_override_hook_source_branch=_override_hook_source_branch)
3104
self.source.unlock()
3106
def _push_with_bound_branches(self, overwrite, stop_revision,
3107
_override_hook_source_branch=None):
3108
"""Push from source into target, and into target's master if any.
3111
if _override_hook_source_branch:
3112
result.source_branch = _override_hook_source_branch
3113
for hook in Branch.hooks['post_push']:
3116
bound_location = self.target.get_bound_location()
3117
if bound_location and self.target.base != bound_location:
3118
# there is a master branch.
3120
# XXX: Why the second check? Is it even supported for a branch to
3121
# be bound to itself? -- mbp 20070507
3122
master_branch = self.target.get_master_branch()
3123
master_branch.lock_write()
3125
# push into the master from the source branch.
3126
self.source._basic_push(master_branch, overwrite, stop_revision)
3127
# and push into the target branch from the source. Note that we
3128
# push from the source branch again, because its considered the
3129
# highest bandwidth repository.
3130
result = self.source._basic_push(self.target, overwrite,
3132
result.master_branch = master_branch
3133
result.local_branch = self.target
3137
master_branch.unlock()
3140
result = self.source._basic_push(self.target, overwrite,
3142
# TODO: Why set master_branch and local_branch if there's no
3143
# binding? Maybe cleaner to just leave them unset? -- mbp
3145
result.master_branch = self.target
3146
result.local_branch = None
3151
def is_compatible(self, source, target):
3152
# GenericBranch uses the public API, so always compatible
3156
class InterToBranch5(GenericInterBranch):
3159
def _get_branch_formats_to_test():
3160
return BranchFormat._default_format, BzrBranchFormat5()
3162
def pull(self, overwrite=False, stop_revision=None,
3163
possible_transports=None, run_hooks=True,
3164
_override_hook_target=None, local=False):
3165
"""Pull from source into self, updating my master if any.
3167
:param run_hooks: Private parameter - if false, this branch
3168
is being called because it's the master of the primary branch,
3169
so it should not run its hooks.
3171
bound_location = self.target.get_bound_location()
3172
if local and not bound_location:
3173
raise errors.LocalRequiresBoundBranch()
3174
master_branch = None
3175
if not local and bound_location and self.source.base != bound_location:
3176
# not pulling from master, so we need to update master.
3177
master_branch = self.target.get_master_branch(possible_transports)
3178
master_branch.lock_write()
3181
# pull from source into master.
3182
master_branch.pull(self.source, overwrite, stop_revision,
3184
return super(InterToBranch5, self).pull(overwrite,
3185
stop_revision, _hook_master=master_branch,
3186
run_hooks=run_hooks,
3187
_override_hook_target=_override_hook_target)
3190
master_branch.unlock()
3193
InterBranch.register_optimiser(GenericInterBranch)
3194
InterBranch.register_optimiser(InterToBranch5)
added
removed
bzrlib/branch.py
