858
792
old_repository = self.repository
859
793
if len(old_repository._fallback_repositories) != 1:
860
794
raise AssertionError("can't cope with fallback repositories "
861
"of %r (fallbacks: %r)" % (old_repository,
862
old_repository._fallback_repositories))
863
# Open the new repository object.
864
# Repositories don't offer an interface to remove fallback
865
# repositories today; take the conceptually simpler option and just
866
# reopen it. We reopen it starting from the URL so that we
867
# get a separate connection for RemoteRepositories and can
868
# stream from one of them to the other. This does mean doing
869
# separate SSH connection setup, but unstacking is not a
870
# common operation so it's tolerable.
871
new_bzrdir = bzrdir.BzrDir.open(self.bzrdir.root_transport.base)
872
new_repository = new_bzrdir.find_repository()
873
if new_repository._fallback_repositories:
874
raise AssertionError("didn't expect %r to have "
875
"fallback_repositories"
876
% (self.repository,))
877
# Replace self.repository with the new repository.
878
# Do our best to transfer the lock state (i.e. lock-tokens and
879
# lock count) of self.repository to the new repository.
880
lock_token = old_repository.lock_write().repository_token
881
self.repository = new_repository
882
if isinstance(self, remote.RemoteBranch):
883
# Remote branches can have a second reference to the old
884
# repository that need to be replaced.
885
if self._real_branch is not None:
886
self._real_branch.repository = new_repository
887
self.repository.lock_write(token=lock_token)
888
if lock_token is not None:
889
old_repository.leave_lock_in_place()
795
"of %r" % (self.repository,))
796
# unlock it, including unlocking the fallback
890
797
old_repository.unlock()
891
if lock_token is not None:
892
# XXX: self.repository.leave_lock_in_place() before this
893
# function will not be preserved. Fortunately that doesn't
894
# affect the current default format (2a), and would be a
895
# corner-case anyway.
896
# - Andrew Bennetts, 2010/06/30
897
self.repository.dont_leave_lock_in_place()
901
old_repository.unlock()
902
except errors.LockNotHeld:
905
if old_lock_count == 0:
906
raise AssertionError(
907
'old_repository should have been locked at least once.')
908
for i in range(old_lock_count-1):
798
old_repository.lock_read()
800
# Repositories don't offer an interface to remove fallback
801
# repositories today; take the conceptually simpler option and just
802
# reopen it. We reopen it starting from the URL so that we
803
# get a separate connection for RemoteRepositories and can
804
# stream from one of them to the other. This does mean doing
805
# separate SSH connection setup, but unstacking is not a
806
# common operation so it's tolerable.
807
new_bzrdir = bzrdir.BzrDir.open(self.bzrdir.root_transport.base)
808
new_repository = new_bzrdir.find_repository()
809
self.repository = new_repository
810
if self.repository._fallback_repositories:
811
raise AssertionError("didn't expect %r to have "
812
"fallback_repositories"
813
% (self.repository,))
814
# this is not paired with an unlock because it's just restoring
815
# the previous state; the lock's released when set_stacked_on_url
909
817
self.repository.lock_write()
910
# Fetch from the old repository into the new.
911
old_repository.lock_read()
913
818
# XXX: If you unstack a branch while it has a working tree
914
819
# with a pending merge, the pending-merged revisions will no
915
820
# longer be present. You can (probably) revert and remerge.
917
tags_to_fetch = set(self.tags.get_reverse_tag_dict())
918
except errors.TagsNotSupported:
919
tags_to_fetch = set()
920
fetch_spec = _mod_graph.NotInOtherForRevs(self.repository,
921
old_repository, required_ids=[self.last_revision()],
922
if_present_ids=tags_to_fetch, find_ghosts=True).execute()
923
self.repository.fetch(old_repository, fetch_spec=fetch_spec)
822
# XXX: This only fetches up to the tip of the repository; it
823
# doesn't bring across any tags. That's fairly consistent
824
# with how branch works, but perhaps not ideal.
825
self.repository.fetch(old_repository,
826
revision_id=self.last_revision(),
925
829
old_repository.unlock()
1030
927
:return: A tuple (revno, revision_id).
1032
929
if self._last_revision_info_cache is None:
1033
self._last_revision_info_cache = self._read_last_revision_info()
930
self._last_revision_info_cache = self._last_revision_info()
1034
931
return self._last_revision_info_cache
1036
def _read_last_revision_info(self):
1037
raise NotImplementedError(self._read_last_revision_info)
1039
@deprecated_method(deprecated_in((2, 4, 0)))
933
def _last_revision_info(self):
934
rh = self.revision_history()
937
return (revno, rh[-1])
939
return (0, _mod_revision.NULL_REVISION)
941
@deprecated_method(deprecated_in((1, 6, 0)))
942
def missing_revisions(self, other, stop_revision=None):
943
"""Return a list of new revisions that would perfectly fit.
945
If self and other have not diverged, return a list of the revisions
946
present in other, but missing from self.
948
self_history = self.revision_history()
949
self_len = len(self_history)
950
other_history = other.revision_history()
951
other_len = len(other_history)
952
common_index = min(self_len, other_len) -1
953
if common_index >= 0 and \
954
self_history[common_index] != other_history[common_index]:
955
raise errors.DivergedBranches(self, other)
957
if stop_revision is None:
958
stop_revision = other_len
960
if stop_revision > other_len:
961
raise errors.NoSuchRevision(self, stop_revision)
962
return other_history[self_len:stop_revision]
965
def update_revisions(self, other, stop_revision=None, overwrite=False,
967
"""Pull in new perfect-fit revisions.
969
:param other: Another Branch to pull from
970
:param stop_revision: Updated until the given revision
971
:param overwrite: Always set the branch pointer, rather than checking
972
to see if it is a proper descendant.
973
:param graph: A Graph object that can be used to query history
974
information. This can be None.
977
return InterBranch.get(other, self).update_revisions(stop_revision,
1040
980
def import_last_revision_info(self, source_repo, revno, revid):
1041
981
"""Set the last revision info, importing from another repo if necessary.
983
This is used by the bound branch code to upload a revision to
984
the master branch first before updating the tip of the local branch.
1043
986
:param source_repo: Source repository to optionally fetch from
1044
987
:param revno: Revision number of the new tip
1045
988
:param revid: Revision id of the new tip
1822
1745
"basis revision. hooks MUST NOT modify this delta. "
1823
1746
" future_tree is an in-memory tree obtained from "
1824
1747
"CommitBuilder.revision_tree() and hooks MUST NOT modify this "
1826
self.add_hook('post_commit',
1748
"tree.", (0,91), None))
1749
self.create_hook(HookPoint('post_commit',
1827
1750
"Called in the bzr client after a commit has completed. "
1828
1751
"post_commit is called with (local, master, old_revno, old_revid, "
1829
1752
"new_revno, new_revid). old_revid is NULL_REVISION for the first "
1830
"commit to a branch.", (0, 15))
1831
self.add_hook('post_uncommit',
1753
"commit to a branch.", (0, 15), None))
1754
self.create_hook(HookPoint('post_uncommit',
1832
1755
"Called in the bzr client after an uncommit completes. "
1833
1756
"post_uncommit is called with (local, master, old_revno, "
1834
1757
"old_revid, new_revno, new_revid) where local is the local branch "
1835
1758
"or None, master is the target branch, and an empty branch "
1836
"receives new_revno of 0, new_revid of None.", (0, 15))
1837
self.add_hook('pre_change_branch_tip',
1759
"receives new_revno of 0, new_revid of None.", (0, 15), None))
1760
self.create_hook(HookPoint('pre_change_branch_tip',
1838
1761
"Called in bzr client and server before a change to the tip of a "
1839
1762
"branch is made. pre_change_branch_tip is called with a "
1840
1763
"bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1841
"commit, uncommit will all trigger this hook.", (1, 6))
1842
self.add_hook('post_change_branch_tip',
1764
"commit, uncommit will all trigger this hook.", (1, 6), None))
1765
self.create_hook(HookPoint('post_change_branch_tip',
1843
1766
"Called in bzr client and server after a change to the tip of a "
1844
1767
"branch is made. post_change_branch_tip is called with a "
1845
1768
"bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1846
"commit, uncommit will all trigger this hook.", (1, 4))
1847
self.add_hook('transform_fallback_location',
1769
"commit, uncommit will all trigger this hook.", (1, 4), None))
1770
self.create_hook(HookPoint('transform_fallback_location',
1848
1771
"Called when a stacked branch is activating its fallback "
1849
1772
"locations. transform_fallback_location is called with (branch, "
1850
1773
"url), and should return a new url. Returning the same url "
2529
2430
"""See Branch.print_file."""
2530
2431
return self.repository.print_file(file, revision_id)
2433
def _write_revision_history(self, history):
2434
"""Factored out of set_revision_history.
2436
This performs the actual writing to disk.
2437
It is intended to be called by BzrBranch5.set_revision_history."""
2438
self._transport.put_bytes(
2439
'revision-history', '\n'.join(history),
2440
mode=self.bzrdir._get_file_mode())
2443
def set_revision_history(self, rev_history):
2444
"""See Branch.set_revision_history."""
2445
if 'evil' in debug.debug_flags:
2446
mutter_callsite(3, "set_revision_history scales with history.")
2447
check_not_reserved_id = _mod_revision.check_not_reserved_id
2448
for rev_id in rev_history:
2449
check_not_reserved_id(rev_id)
2450
if Branch.hooks['post_change_branch_tip']:
2451
# Don't calculate the last_revision_info() if there are no hooks
2453
old_revno, old_revid = self.last_revision_info()
2454
if len(rev_history) == 0:
2455
revid = _mod_revision.NULL_REVISION
2457
revid = rev_history[-1]
2458
self._run_pre_change_branch_tip_hooks(len(rev_history), revid)
2459
self._write_revision_history(rev_history)
2460
self._clear_cached_state()
2461
self._cache_revision_history(rev_history)
2462
for hook in Branch.hooks['set_rh']:
2463
hook(self, rev_history)
2464
if Branch.hooks['post_change_branch_tip']:
2465
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2467
def _synchronize_history(self, destination, revision_id):
2468
"""Synchronize last revision and revision history between branches.
2470
This version is most efficient when the destination is also a
2471
BzrBranch5, but works for BzrBranch6 as long as the revision
2472
history is the true lefthand parent history, and all of the revisions
2473
are in the destination's repository. If not, set_revision_history
2476
:param destination: The branch to copy the history into
2477
:param revision_id: The revision-id to truncate history at. May
2478
be None to copy complete history.
2480
if not isinstance(destination._format, BzrBranchFormat5):
2481
super(BzrBranch, self)._synchronize_history(
2482
destination, revision_id)
2484
if revision_id == _mod_revision.NULL_REVISION:
2487
new_history = self.revision_history()
2488
if revision_id is not None and new_history != []:
2490
new_history = new_history[:new_history.index(revision_id) + 1]
2492
rev = self.repository.get_revision(revision_id)
2493
new_history = rev.get_history(self.repository)[1:]
2494
destination.set_revision_history(new_history)
2532
2496
@needs_write_lock
2533
2497
def set_last_revision_info(self, revno, revision_id):
2534
if not revision_id or not isinstance(revision_id, basestring):
2535
raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2498
"""Set the last revision of this branch.
2500
The caller is responsible for checking that the revno is correct
2501
for this revision id.
2503
It may be possible to set the branch last revision to an id not
2504
present in the repository. However, branches can also be
2505
configured to check constraints on history, in which case this may not
2536
2508
revision_id = _mod_revision.ensure_null(revision_id)
2537
old_revno, old_revid = self.last_revision_info()
2538
if self.get_append_revisions_only():
2539
self._check_history_violation(revision_id)
2540
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2541
self._write_last_revision_info(revno, revision_id)
2542
self._clear_cached_state()
2543
self._last_revision_info_cache = revno, revision_id
2544
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2509
# this old format stores the full history, but this api doesn't
2510
# provide it, so we must generate, and might as well check it's
2512
history = self._lefthand_history(revision_id)
2513
if len(history) != revno:
2514
raise AssertionError('%d != %d' % (len(history), revno))
2515
self.set_revision_history(history)
2517
def _gen_revision_history(self):
2518
history = self._transport.get_bytes('revision-history').split('\n')
2519
if history[-1:] == ['']:
2520
# There shouldn't be a trailing newline, but just in case.
2525
def generate_revision_history(self, revision_id, last_rev=None,
2527
"""Create a new revision history that will finish with revision_id.
2529
:param revision_id: the new tip to use.
2530
:param last_rev: The previous last_revision. If not None, then this
2531
must be a ancestory of revision_id, or DivergedBranches is raised.
2532
:param other_branch: The other branch that DivergedBranches should
2533
raise with respect to.
2535
self.set_revision_history(self._lefthand_history(revision_id,
2536
last_rev, other_branch))
2546
2538
def basis_tree(self):
2547
2539
"""See Branch.basis_tree."""
2668
def _read_last_revision_info(self):
2669
revision_string = self._transport.get_bytes('last-revision')
2670
revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
2671
revision_id = cache_utf8.get_cached_utf8(revision_id)
2673
return revno, revision_id
2675
def _write_last_revision_info(self, revno, revision_id):
2676
"""Simply write out the revision id, with no checks.
2678
Use set_last_revision_info to perform this safely.
2680
Does not update the revision_history cache.
2682
revision_id = _mod_revision.ensure_null(revision_id)
2683
out_string = '%d %s\n' % (revno, revision_id)
2684
self._transport.put_bytes('last-revision', out_string,
2685
mode=self.bzrdir._get_file_mode())
2688
class FullHistoryBzrBranch(BzrBranch):
2689
"""Bzr branch which contains the full revision history."""
2692
def set_last_revision_info(self, revno, revision_id):
2693
if not revision_id or not isinstance(revision_id, basestring):
2694
raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2695
revision_id = _mod_revision.ensure_null(revision_id)
2696
# this old format stores the full history, but this api doesn't
2697
# provide it, so we must generate, and might as well check it's
2699
history = self._lefthand_history(revision_id)
2700
if len(history) != revno:
2701
raise AssertionError('%d != %d' % (len(history), revno))
2702
self._set_revision_history(history)
2704
def _read_last_revision_info(self):
2705
rh = self.revision_history()
2708
return (revno, rh[-1])
2710
return (0, _mod_revision.NULL_REVISION)
2712
@deprecated_method(deprecated_in((2, 4, 0)))
2714
def set_revision_history(self, rev_history):
2715
"""See Branch.set_revision_history."""
2716
self._set_revision_history(rev_history)
2718
def _set_revision_history(self, rev_history):
2719
if 'evil' in debug.debug_flags:
2720
mutter_callsite(3, "set_revision_history scales with history.")
2721
check_not_reserved_id = _mod_revision.check_not_reserved_id
2722
for rev_id in rev_history:
2723
check_not_reserved_id(rev_id)
2724
if Branch.hooks['post_change_branch_tip']:
2725
# Don't calculate the last_revision_info() if there are no hooks
2727
old_revno, old_revid = self.last_revision_info()
2728
if len(rev_history) == 0:
2729
revid = _mod_revision.NULL_REVISION
2731
revid = rev_history[-1]
2732
self._run_pre_change_branch_tip_hooks(len(rev_history), revid)
2733
self._write_revision_history(rev_history)
2734
self._clear_cached_state()
2735
self._cache_revision_history(rev_history)
2736
for hook in Branch.hooks['set_rh']:
2737
hook(self, rev_history)
2738
if Branch.hooks['post_change_branch_tip']:
2739
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2741
def _write_revision_history(self, history):
2742
"""Factored out of set_revision_history.
2744
This performs the actual writing to disk.
2745
It is intended to be called by set_revision_history."""
2746
self._transport.put_bytes(
2747
'revision-history', '\n'.join(history),
2748
mode=self.bzrdir._get_file_mode())
2750
def _gen_revision_history(self):
2751
history = self._transport.get_bytes('revision-history').split('\n')
2752
if history[-1:] == ['']:
2753
# There shouldn't be a trailing newline, but just in case.
2757
def _synchronize_history(self, destination, revision_id):
2758
if not isinstance(destination, FullHistoryBzrBranch):
2759
super(BzrBranch, self)._synchronize_history(
2760
destination, revision_id)
2762
if revision_id == _mod_revision.NULL_REVISION:
2765
new_history = self.revision_history()
2766
if revision_id is not None and new_history != []:
2768
new_history = new_history[:new_history.index(revision_id) + 1]
2770
rev = self.repository.get_revision(revision_id)
2771
new_history = rev.get_history(self.repository)[1:]
2772
destination._set_revision_history(new_history)
2775
def generate_revision_history(self, revision_id, last_rev=None,
2777
"""Create a new revision history that will finish with revision_id.
2779
:param revision_id: the new tip to use.
2780
:param last_rev: The previous last_revision. If not None, then this
2781
must be a ancestory of revision_id, or DivergedBranches is raised.
2782
:param other_branch: The other branch that DivergedBranches should
2783
raise with respect to.
2785
self._set_revision_history(self._lefthand_history(revision_id,
2786
last_rev, other_branch))
2789
class BzrBranch5(FullHistoryBzrBranch):
2790
"""A format 5 branch. This supports new features over plain branches.
2792
It has support for a master_branch which is the data for bound branches.
2796
class BzrBranch8(BzrBranch):
2688
class BzrBranch8(BzrBranch5):
2797
2689
"""A branch that stores tree-reference locations."""
2799
2691
def _open_hook(self):
2825
2717
self._last_revision_info_cache = None
2826
2718
self._reference_info = None
2720
def _last_revision_info(self):
2721
revision_string = self._transport.get_bytes('last-revision')
2722
revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
2723
revision_id = cache_utf8.get_cached_utf8(revision_id)
2725
return revno, revision_id
2727
def _write_last_revision_info(self, revno, revision_id):
2728
"""Simply write out the revision id, with no checks.
2730
Use set_last_revision_info to perform this safely.
2732
Does not update the revision_history cache.
2733
Intended to be called by set_last_revision_info and
2734
_write_revision_history.
2736
revision_id = _mod_revision.ensure_null(revision_id)
2737
out_string = '%d %s\n' % (revno, revision_id)
2738
self._transport.put_bytes('last-revision', out_string,
2739
mode=self.bzrdir._get_file_mode())
2742
def set_last_revision_info(self, revno, revision_id):
2743
revision_id = _mod_revision.ensure_null(revision_id)
2744
old_revno, old_revid = self.last_revision_info()
2745
if self._get_append_revisions_only():
2746
self._check_history_violation(revision_id)
2747
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2748
self._write_last_revision_info(revno, revision_id)
2749
self._clear_cached_state()
2750
self._last_revision_info_cache = revno, revision_id
2751
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2753
def _synchronize_history(self, destination, revision_id):
2754
"""Synchronize last revision and revision history between branches.
2756
:see: Branch._synchronize_history
2758
# XXX: The base Branch has a fast implementation of this method based
2759
# on set_last_revision_info, but BzrBranch/BzrBranch5 have a slower one
2760
# that uses set_revision_history. This class inherits from BzrBranch5,
2761
# but wants the fast implementation, so it calls
2762
# Branch._synchronize_history directly.
2763
Branch._synchronize_history(self, destination, revision_id)
2828
2765
def _check_history_violation(self, revision_id):
2829
current_revid = self.last_revision()
2830
last_revision = _mod_revision.ensure_null(current_revid)
2766
last_revision = _mod_revision.ensure_null(self.last_revision())
2831
2767
if _mod_revision.is_null(last_revision):
2833
graph = self.repository.get_graph()
2834
for lh_ancestor in graph.iter_lefthand_ancestry(revision_id):
2835
if lh_ancestor == current_revid:
2837
raise errors.AppendRevisionsOnlyViolation(self.user_url)
2769
if last_revision not in self._lefthand_history(revision_id):
2770
raise errors.AppendRevisionsOnlyViolation(self.user_url)
2839
2772
def _gen_revision_history(self):
2840
2773
"""Generate the revision history from last revision
3260
3225
raise NotImplementedError(self.push)
3263
def copy_content_into(self, revision_id=None):
3264
"""Copy the content of source into target
3266
revision_id: if not None, the revision history in the new branch will
3267
be truncated to end with revision_id.
3269
raise NotImplementedError(self.copy_content_into)
3272
def fetch(self, stop_revision=None, limit=None):
3275
:param stop_revision: Last revision to fetch
3276
:param limit: Optional rough limit of revisions to fetch
3278
raise NotImplementedError(self.fetch)
3281
3228
class GenericInterBranch(InterBranch):
3282
"""InterBranch implementation that uses public Branch functions."""
3285
def is_compatible(klass, source, target):
3286
# GenericBranch uses the public API, so always compatible
3290
def _get_branch_formats_to_test(klass):
3291
return [(format_registry.get_default(), format_registry.get_default())]
3294
def unwrap_format(klass, format):
3295
if isinstance(format, remote.RemoteBranchFormat):
3296
format._ensure_real()
3297
return format._custom_format
3301
def copy_content_into(self, revision_id=None):
3302
"""Copy the content of source into target
3304
revision_id: if not None, the revision history in the new branch will
3305
be truncated to end with revision_id.
3307
self.source.update_references(self.target)
3308
self.source._synchronize_history(self.target, revision_id)
3310
parent = self.source.get_parent()
3311
except errors.InaccessibleParent, e:
3312
mutter('parent was not accessible to copy: %s', e)
3315
self.target.set_parent(parent)
3316
if self.source._push_should_merge_tags():
3317
self.source.tags.merge_to(self.target.tags)
3320
def fetch(self, stop_revision=None, limit=None):
3321
if self.target.base == self.source.base:
3229
"""InterBranch implementation that uses public Branch functions.
3233
def _get_branch_formats_to_test():
3234
return BranchFormat._default_format, BranchFormat._default_format
3236
def update_revisions(self, stop_revision=None, overwrite=False,
3238
"""See InterBranch.update_revisions()."""
3323
3239
self.source.lock_read()
3325
fetch_spec_factory = fetch.FetchSpecFactory()
3326
fetch_spec_factory.source_branch = self.source
3327
fetch_spec_factory.source_branch_stop_revision_id = stop_revision
3328
fetch_spec_factory.source_repo = self.source.repository
3329
fetch_spec_factory.target_repo = self.target.repository
3330
fetch_spec_factory.target_repo_kind = fetch.TargetRepoKinds.PREEXISTING
3331
fetch_spec_factory.limit = limit
3332
fetch_spec = fetch_spec_factory.make_fetch_spec()
3333
return self.target.repository.fetch(self.source.repository,
3334
fetch_spec=fetch_spec)
3241
other_revno, other_last_revision = self.source.last_revision_info()
3242
stop_revno = None # unknown
3243
if stop_revision is None:
3244
stop_revision = other_last_revision
3245
if _mod_revision.is_null(stop_revision):
3246
# if there are no commits, we're done.
3248
stop_revno = other_revno
3250
# what's the current last revision, before we fetch [and change it
3252
last_rev = _mod_revision.ensure_null(self.target.last_revision())
3253
# we fetch here so that we don't process data twice in the common
3254
# case of having something to pull, and so that the check for
3255
# already merged can operate on the just fetched graph, which will
3256
# be cached in memory.
3257
self.target.fetch(self.source, stop_revision)
3258
# Check to see if one is an ancestor of the other
3261
graph = self.target.repository.get_graph()
3262
if self.target._check_if_descendant_or_diverged(
3263
stop_revision, last_rev, graph, self.source):
3264
# stop_revision is a descendant of last_rev, but we aren't
3265
# overwriting, so we're done.
3267
if stop_revno is None:
3269
graph = self.target.repository.get_graph()
3270
this_revno, this_last_revision = \
3271
self.target.last_revision_info()
3272
stop_revno = graph.find_distance_to_null(stop_revision,
3273
[(other_last_revision, other_revno),
3274
(this_last_revision, this_revno)])
3275
self.target.set_last_revision_info(stop_revno, stop_revision)
3336
3277
self.source.unlock()
3339
def _update_revisions(self, stop_revision=None, overwrite=False,
3341
other_revno, other_last_revision = self.source.last_revision_info()
3342
stop_revno = None # unknown
3343
if stop_revision is None:
3344
stop_revision = other_last_revision
3345
if _mod_revision.is_null(stop_revision):
3346
# if there are no commits, we're done.
3348
stop_revno = other_revno
3350
# what's the current last revision, before we fetch [and change it
3352
last_rev = _mod_revision.ensure_null(self.target.last_revision())
3353
# we fetch here so that we don't process data twice in the common
3354
# case of having something to pull, and so that the check for
3355
# already merged can operate on the just fetched graph, which will
3356
# be cached in memory.
3357
self.fetch(stop_revision=stop_revision)
3358
# Check to see if one is an ancestor of the other
3361
graph = self.target.repository.get_graph()
3362
if self.target._check_if_descendant_or_diverged(
3363
stop_revision, last_rev, graph, self.source):
3364
# stop_revision is a descendant of last_rev, but we aren't
3365
# overwriting, so we're done.
3367
if stop_revno is None:
3369
graph = self.target.repository.get_graph()
3370
this_revno, this_last_revision = \
3371
self.target.last_revision_info()
3372
stop_revno = graph.find_distance_to_null(stop_revision,
3373
[(other_last_revision, other_revno),
3374
(this_last_revision, this_revno)])
3375
self.target.set_last_revision_info(stop_revno, stop_revision)
3378
3279
def pull(self, overwrite=False, stop_revision=None,
3379
possible_transports=None, run_hooks=True,
3380
_override_hook_target=None, local=False):
3381
"""Pull from source into self, updating my master if any.
3383
:param run_hooks: Private parameter - if false, this branch
3384
is being called because it's the master of the primary branch,
3385
so it should not run its hooks.
3387
bound_location = self.target.get_bound_location()
3388
if local and not bound_location:
3389
raise errors.LocalRequiresBoundBranch()
3390
master_branch = None
3391
source_is_master = False
3393
# bound_location comes from a config file, some care has to be
3394
# taken to relate it to source.user_url
3395
normalized = urlutils.normalize_url(bound_location)
3397
relpath = self.source.user_transport.relpath(normalized)
3398
source_is_master = (relpath == '')
3399
except (errors.PathNotChild, errors.InvalidURL):
3400
source_is_master = False
3401
if not local and bound_location and not source_is_master:
3402
# not pulling from master, so we need to update master.
3403
master_branch = self.target.get_master_branch(possible_transports)
3404
master_branch.lock_write()
3407
# pull from source into master.
3408
master_branch.pull(self.source, overwrite, stop_revision,
3410
return self._pull(overwrite,
3411
stop_revision, _hook_master=master_branch,
3412
run_hooks=run_hooks,
3413
_override_hook_target=_override_hook_target,
3414
merge_tags_to_master=not source_is_master)
3417
master_branch.unlock()
3419
def push(self, overwrite=False, stop_revision=None, lossy=False,
3420
_override_hook_source_branch=None):
3421
"""See InterBranch.push.
3423
This is the basic concrete implementation of push()
3425
:param _override_hook_source_branch: If specified, run the hooks
3426
passing this Branch as the source, rather than self. This is for
3427
use of RemoteBranch, where push is delegated to the underlying
3431
raise errors.LossyPushToSameVCS(self.source, self.target)
3432
# TODO: Public option to disable running hooks - should be trivial but
3435
op = cleanup.OperationWithCleanups(self._push_with_bound_branches)
3436
op.add_cleanup(self.source.lock_read().unlock)
3437
op.add_cleanup(self.target.lock_write().unlock)
3438
return op.run(overwrite, stop_revision,
3439
_override_hook_source_branch=_override_hook_source_branch)
3441
def _basic_push(self, overwrite, stop_revision):
3442
"""Basic implementation of push without bound branches or hooks.
3444
Must be called with source read locked and target write locked.
3446
result = BranchPushResult()
3447
result.source_branch = self.source
3448
result.target_branch = self.target
3449
result.old_revno, result.old_revid = self.target.last_revision_info()
3450
self.source.update_references(self.target)
3451
if result.old_revid != stop_revision:
3452
# We assume that during 'push' this repository is closer than
3454
graph = self.source.repository.get_graph(self.target.repository)
3455
self._update_revisions(stop_revision, overwrite=overwrite,
3457
if self.source._push_should_merge_tags():
3458
result.tag_updates, result.tag_conflicts = (
3459
self.source.tags.merge_to(self.target.tags, overwrite))
3460
result.new_revno, result.new_revid = self.target.last_revision_info()
3463
def _push_with_bound_branches(self, operation, overwrite, stop_revision,
3464
_override_hook_source_branch=None):
3465
"""Push from source into target, and into target's master if any.
3468
if _override_hook_source_branch:
3469
result.source_branch = _override_hook_source_branch
3470
for hook in Branch.hooks['post_push']:
3473
bound_location = self.target.get_bound_location()
3474
if bound_location and self.target.base != bound_location:
3475
# there is a master branch.
3477
# XXX: Why the second check? Is it even supported for a branch to
3478
# be bound to itself? -- mbp 20070507
3479
master_branch = self.target.get_master_branch()
3480
master_branch.lock_write()
3481
operation.add_cleanup(master_branch.unlock)
3482
# push into the master from the source branch.
3483
master_inter = InterBranch.get(self.source, master_branch)
3484
master_inter._basic_push(overwrite, stop_revision)
3485
# and push into the target branch from the source. Note that
3486
# we push from the source branch again, because it's considered
3487
# the highest bandwidth repository.
3488
result = self._basic_push(overwrite, stop_revision)
3489
result.master_branch = master_branch
3490
result.local_branch = self.target
3492
master_branch = None
3494
result = self._basic_push(overwrite, stop_revision)
3495
# TODO: Why set master_branch and local_branch if there's no
3496
# binding? Maybe cleaner to just leave them unset? -- mbp
3498
result.master_branch = self.target
3499
result.local_branch = None
3503
def _pull(self, overwrite=False, stop_revision=None,
3504
3280
possible_transports=None, _hook_master=None, run_hooks=True,
3505
_override_hook_target=None, local=False,
3506
merge_tags_to_master=True):
3281
_override_hook_target=None, local=False):
3507
3282
"""See Branch.pull.
3509
This function is the core worker, used by GenericInterBranch.pull to
3510
avoid duplication when pulling source->master and source->local.
3512
3284
:param _hook_master: Private parameter - set the branch to
3513
3285
be supplied as the master to pull hooks.
3514
3286
:param run_hooks: Private parameter - if false, this branch
3515
3287
is being called because it's the master of the primary branch,
3516
3288
so it should not run its hooks.
3517
is being called because it's the master of the primary branch,
3518
so it should not run its hooks.
3519
3289
:param _override_hook_target: Private parameter - set the branch to be
3520
3290
supplied as the target_branch to pull hooks.
3521
3291
:param local: Only update the local branch, and not the bound branch.
3562
3331
self.source.unlock()
3334
def push(self, overwrite=False, stop_revision=None,
3335
_override_hook_source_branch=None):
3336
"""See InterBranch.push.
3338
This is the basic concrete implementation of push()
3340
:param _override_hook_source_branch: If specified, run
3341
the hooks passing this Branch as the source, rather than self.
3342
This is for use of RemoteBranch, where push is delegated to the
3343
underlying vfs-based Branch.
3345
# TODO: Public option to disable running hooks - should be trivial but
3347
self.source.lock_read()
3349
return _run_with_write_locked_target(
3350
self.target, self._push_with_bound_branches, overwrite,
3352
_override_hook_source_branch=_override_hook_source_branch)
3354
self.source.unlock()
3356
def _push_with_bound_branches(self, overwrite, stop_revision,
3357
_override_hook_source_branch=None):
3358
"""Push from source into target, and into target's master if any.
3361
if _override_hook_source_branch:
3362
result.source_branch = _override_hook_source_branch
3363
for hook in Branch.hooks['post_push']:
3366
bound_location = self.target.get_bound_location()
3367
if bound_location and self.target.base != bound_location:
3368
# there is a master branch.
3370
# XXX: Why the second check? Is it even supported for a branch to
3371
# be bound to itself? -- mbp 20070507
3372
master_branch = self.target.get_master_branch()
3373
master_branch.lock_write()
3375
# push into the master from the source branch.
3376
self.source._basic_push(master_branch, overwrite, stop_revision)
3377
# and push into the target branch from the source. Note that we
3378
# push from the source branch again, because its considered the
3379
# highest bandwidth repository.
3380
result = self.source._basic_push(self.target, overwrite,
3382
result.master_branch = master_branch
3383
result.local_branch = self.target
3387
master_branch.unlock()
3390
result = self.source._basic_push(self.target, overwrite,
3392
# TODO: Why set master_branch and local_branch if there's no
3393
# binding? Maybe cleaner to just leave them unset? -- mbp
3395
result.master_branch = self.target
3396
result.local_branch = None
3401
def is_compatible(self, source, target):
3402
# GenericBranch uses the public API, so always compatible
3406
class InterToBranch5(GenericInterBranch):
3409
def _get_branch_formats_to_test():
3410
return BranchFormat._default_format, BzrBranchFormat5()
3412
def pull(self, overwrite=False, stop_revision=None,
3413
possible_transports=None, run_hooks=True,
3414
_override_hook_target=None, local=False):
3415
"""Pull from source into self, updating my master if any.
3417
:param run_hooks: Private parameter - if false, this branch
3418
is being called because it's the master of the primary branch,
3419
so it should not run its hooks.
3421
bound_location = self.target.get_bound_location()
3422
if local and not bound_location:
3423
raise errors.LocalRequiresBoundBranch()
3424
master_branch = None
3425
if not local and bound_location and self.source.user_url != bound_location:
3426
# not pulling from master, so we need to update master.
3427
master_branch = self.target.get_master_branch(possible_transports)
3428
master_branch.lock_write()
3431
# pull from source into master.
3432
master_branch.pull(self.source, overwrite, stop_revision,
3434
return super(InterToBranch5, self).pull(overwrite,
3435
stop_revision, _hook_master=master_branch,
3436
run_hooks=run_hooks,
3437
_override_hook_target=_override_hook_target)
3440
master_branch.unlock()
3566
3443
InterBranch.register_optimiser(GenericInterBranch)
3444
InterBranch.register_optimiser(InterToBranch5)
added
removed
bzrlib/branch.py
