793
859
old_repository = self.repository
794
860
if len(old_repository._fallback_repositories) != 1:
795
861
raise AssertionError("can't cope with fallback repositories "
796
"of %r" % (self.repository,))
797
# unlock it, including unlocking the fallback
862
"of %r (fallbacks: %r)" % (old_repository,
863
old_repository._fallback_repositories))
864
# Open the new repository object.
865
# Repositories don't offer an interface to remove fallback
866
# repositories today; take the conceptually simpler option and just
867
# reopen it. We reopen it starting from the URL so that we
868
# get a separate connection for RemoteRepositories and can
869
# stream from one of them to the other. This does mean doing
870
# separate SSH connection setup, but unstacking is not a
871
# common operation so it's tolerable.
872
new_bzrdir = bzrdir.BzrDir.open(self.bzrdir.root_transport.base)
873
new_repository = new_bzrdir.find_repository()
874
if new_repository._fallback_repositories:
875
raise AssertionError("didn't expect %r to have "
876
"fallback_repositories"
877
% (self.repository,))
878
# Replace self.repository with the new repository.
879
# Do our best to transfer the lock state (i.e. lock-tokens and
880
# lock count) of self.repository to the new repository.
881
lock_token = old_repository.lock_write().repository_token
882
self.repository = new_repository
883
if isinstance(self, remote.RemoteBranch):
884
# Remote branches can have a second reference to the old
885
# repository that need to be replaced.
886
if self._real_branch is not None:
887
self._real_branch.repository = new_repository
888
self.repository.lock_write(token=lock_token)
889
if lock_token is not None:
890
old_repository.leave_lock_in_place()
798
891
old_repository.unlock()
892
if lock_token is not None:
893
# XXX: self.repository.leave_lock_in_place() before this
894
# function will not be preserved. Fortunately that doesn't
895
# affect the current default format (2a), and would be a
896
# corner-case anyway.
897
# - Andrew Bennetts, 2010/06/30
898
self.repository.dont_leave_lock_in_place()
902
old_repository.unlock()
903
except errors.LockNotHeld:
906
if old_lock_count == 0:
907
raise AssertionError(
908
'old_repository should have been locked at least once.')
909
for i in range(old_lock_count-1):
910
self.repository.lock_write()
911
# Fetch from the old repository into the new.
799
912
old_repository.lock_read()
801
# Repositories don't offer an interface to remove fallback
802
# repositories today; take the conceptually simpler option and just
803
# reopen it. We reopen it starting from the URL so that we
804
# get a separate connection for RemoteRepositories and can
805
# stream from one of them to the other. This does mean doing
806
# separate SSH connection setup, but unstacking is not a
807
# common operation so it's tolerable.
808
new_bzrdir = bzrdir.BzrDir.open(self.bzrdir.root_transport.base)
809
new_repository = new_bzrdir.find_repository()
810
self.repository = new_repository
811
if self.repository._fallback_repositories:
812
raise AssertionError("didn't expect %r to have "
813
"fallback_repositories"
814
% (self.repository,))
815
# this is not paired with an unlock because it's just restoring
816
# the previous state; the lock's released when set_stacked_on_url
818
self.repository.lock_write()
819
914
# XXX: If you unstack a branch while it has a working tree
820
915
# with a pending merge, the pending-merged revisions will no
821
916
# longer be present. You can (probably) revert and remerge.
823
# XXX: This only fetches up to the tip of the repository; it
824
# doesn't bring across any tags. That's fairly consistent
825
# with how branch works, but perhaps not ideal.
826
self.repository.fetch(old_repository,
827
revision_id=self.last_revision(),
918
tags_to_fetch = set(self.tags.get_reverse_tag_dict())
919
except errors.TagsNotSupported:
920
tags_to_fetch = set()
921
fetch_spec = _mod_graph.NotInOtherForRevs(self.repository,
922
old_repository, required_ids=[self.last_revision()],
923
if_present_ids=tags_to_fetch, find_ghosts=True).execute()
924
self.repository.fetch(old_repository, fetch_spec=fetch_spec)
830
926
old_repository.unlock()
928
1031
:return: A tuple (revno, revision_id).
930
1033
if self._last_revision_info_cache is None:
931
self._last_revision_info_cache = self._last_revision_info()
1034
self._last_revision_info_cache = self._read_last_revision_info()
932
1035
return self._last_revision_info_cache
934
def _last_revision_info(self):
935
rh = self.revision_history()
938
return (revno, rh[-1])
940
return (0, _mod_revision.NULL_REVISION)
942
@deprecated_method(deprecated_in((1, 6, 0)))
943
def missing_revisions(self, other, stop_revision=None):
944
"""Return a list of new revisions that would perfectly fit.
946
If self and other have not diverged, return a list of the revisions
947
present in other, but missing from self.
949
self_history = self.revision_history()
950
self_len = len(self_history)
951
other_history = other.revision_history()
952
other_len = len(other_history)
953
common_index = min(self_len, other_len) -1
954
if common_index >= 0 and \
955
self_history[common_index] != other_history[common_index]:
956
raise errors.DivergedBranches(self, other)
958
if stop_revision is None:
959
stop_revision = other_len
961
if stop_revision > other_len:
962
raise errors.NoSuchRevision(self, stop_revision)
963
return other_history[self_len:stop_revision]
966
def update_revisions(self, other, stop_revision=None, overwrite=False,
968
"""Pull in new perfect-fit revisions.
970
:param other: Another Branch to pull from
971
:param stop_revision: Updated until the given revision
972
:param overwrite: Always set the branch pointer, rather than checking
973
to see if it is a proper descendant.
974
:param graph: A Graph object that can be used to query history
975
information. This can be None.
978
return InterBranch.get(other, self).update_revisions(stop_revision,
1037
def _read_last_revision_info(self):
1038
raise NotImplementedError(self._read_last_revision_info)
1040
@deprecated_method(deprecated_in((2, 4, 0)))
981
1041
def import_last_revision_info(self, source_repo, revno, revid):
982
1042
"""Set the last revision info, importing from another repo if necessary.
984
This is used by the bound branch code to upload a revision to
985
the master branch first before updating the tip of the local branch.
987
1044
:param source_repo: Source repository to optionally fetch from
988
1045
:param revno: Revision number of the new tip
989
1046
:param revid: Revision id of the new tip
1715
1785
These are all empty initially, because by default nothing should get
1718
Hooks.__init__(self)
1719
self.create_hook(HookPoint('set_rh',
1788
Hooks.__init__(self, "bzrlib.branch", "Branch.hooks")
1789
self.add_hook('set_rh',
1720
1790
"Invoked whenever the revision history has been set via "
1721
1791
"set_revision_history. The api signature is (branch, "
1722
1792
"revision_history), and the branch will be write-locked. "
1723
1793
"The set_rh hook can be expensive for bzr to trigger, a better "
1724
"hook to use is Branch.post_change_branch_tip.", (0, 15), None))
1725
self.create_hook(HookPoint('open',
1794
"hook to use is Branch.post_change_branch_tip.", (0, 15))
1795
self.add_hook('open',
1726
1796
"Called with the Branch object that has been opened after a "
1727
"branch is opened.", (1, 8), None))
1728
self.create_hook(HookPoint('post_push',
1797
"branch is opened.", (1, 8))
1798
self.add_hook('post_push',
1729
1799
"Called after a push operation completes. post_push is called "
1730
1800
"with a bzrlib.branch.BranchPushResult object and only runs in the "
1731
"bzr client.", (0, 15), None))
1732
self.create_hook(HookPoint('post_pull',
1801
"bzr client.", (0, 15))
1802
self.add_hook('post_pull',
1733
1803
"Called after a pull operation completes. post_pull is called "
1734
1804
"with a bzrlib.branch.PullResult object and only runs in the "
1735
"bzr client.", (0, 15), None))
1736
self.create_hook(HookPoint('pre_commit',
1737
"Called after a commit is calculated but before it is is "
1805
"bzr client.", (0, 15))
1806
self.add_hook('pre_commit',
1807
"Called after a commit is calculated but before it is "
1738
1808
"completed. pre_commit is called with (local, master, old_revno, "
1739
1809
"old_revid, future_revno, future_revid, tree_delta, future_tree"
1740
1810
"). old_revid is NULL_REVISION for the first commit to a branch, "
1742
1812
"basis revision. hooks MUST NOT modify this delta. "
1743
1813
" future_tree is an in-memory tree obtained from "
1744
1814
"CommitBuilder.revision_tree() and hooks MUST NOT modify this "
1745
"tree.", (0,91), None))
1746
self.create_hook(HookPoint('post_commit',
1816
self.add_hook('post_commit',
1747
1817
"Called in the bzr client after a commit has completed. "
1748
1818
"post_commit is called with (local, master, old_revno, old_revid, "
1749
1819
"new_revno, new_revid). old_revid is NULL_REVISION for the first "
1750
"commit to a branch.", (0, 15), None))
1751
self.create_hook(HookPoint('post_uncommit',
1820
"commit to a branch.", (0, 15))
1821
self.add_hook('post_uncommit',
1752
1822
"Called in the bzr client after an uncommit completes. "
1753
1823
"post_uncommit is called with (local, master, old_revno, "
1754
1824
"old_revid, new_revno, new_revid) where local is the local branch "
1755
1825
"or None, master is the target branch, and an empty branch "
1756
"receives new_revno of 0, new_revid of None.", (0, 15), None))
1757
self.create_hook(HookPoint('pre_change_branch_tip',
1826
"receives new_revno of 0, new_revid of None.", (0, 15))
1827
self.add_hook('pre_change_branch_tip',
1758
1828
"Called in bzr client and server before a change to the tip of a "
1759
1829
"branch is made. pre_change_branch_tip is called with a "
1760
1830
"bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1761
"commit, uncommit will all trigger this hook.", (1, 6), None))
1762
self.create_hook(HookPoint('post_change_branch_tip',
1831
"commit, uncommit will all trigger this hook.", (1, 6))
1832
self.add_hook('post_change_branch_tip',
1763
1833
"Called in bzr client and server after a change to the tip of a "
1764
1834
"branch is made. post_change_branch_tip is called with a "
1765
1835
"bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1766
"commit, uncommit will all trigger this hook.", (1, 4), None))
1767
self.create_hook(HookPoint('transform_fallback_location',
1836
"commit, uncommit will all trigger this hook.", (1, 4))
1837
self.add_hook('transform_fallback_location',
1768
1838
"Called when a stacked branch is activating its fallback "
1769
1839
"locations. transform_fallback_location is called with (branch, "
1770
1840
"url), and should return a new url. Returning the same url "
2428
2500
"""See Branch.print_file."""
2429
2501
return self.repository.print_file(file, revision_id)
2431
def _write_revision_history(self, history):
2432
"""Factored out of set_revision_history.
2434
This performs the actual writing to disk.
2435
It is intended to be called by BzrBranch5.set_revision_history."""
2436
self._transport.put_bytes(
2437
'revision-history', '\n'.join(history),
2438
mode=self.bzrdir._get_file_mode())
2441
def set_revision_history(self, rev_history):
2442
"""See Branch.set_revision_history."""
2443
if 'evil' in debug.debug_flags:
2444
mutter_callsite(3, "set_revision_history scales with history.")
2445
check_not_reserved_id = _mod_revision.check_not_reserved_id
2446
for rev_id in rev_history:
2447
check_not_reserved_id(rev_id)
2448
if Branch.hooks['post_change_branch_tip']:
2449
# Don't calculate the last_revision_info() if there are no hooks
2451
old_revno, old_revid = self.last_revision_info()
2452
if len(rev_history) == 0:
2453
revid = _mod_revision.NULL_REVISION
2455
revid = rev_history[-1]
2456
self._run_pre_change_branch_tip_hooks(len(rev_history), revid)
2457
self._write_revision_history(rev_history)
2458
self._clear_cached_state()
2459
self._cache_revision_history(rev_history)
2460
for hook in Branch.hooks['set_rh']:
2461
hook(self, rev_history)
2462
if Branch.hooks['post_change_branch_tip']:
2463
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2465
def _synchronize_history(self, destination, revision_id):
2466
"""Synchronize last revision and revision history between branches.
2468
This version is most efficient when the destination is also a
2469
BzrBranch5, but works for BzrBranch6 as long as the revision
2470
history is the true lefthand parent history, and all of the revisions
2471
are in the destination's repository. If not, set_revision_history
2474
:param destination: The branch to copy the history into
2475
:param revision_id: The revision-id to truncate history at. May
2476
be None to copy complete history.
2478
if not isinstance(destination._format, BzrBranchFormat5):
2479
super(BzrBranch, self)._synchronize_history(
2480
destination, revision_id)
2482
if revision_id == _mod_revision.NULL_REVISION:
2485
new_history = self.revision_history()
2486
if revision_id is not None and new_history != []:
2488
new_history = new_history[:new_history.index(revision_id) + 1]
2490
rev = self.repository.get_revision(revision_id)
2491
new_history = rev.get_history(self.repository)[1:]
2492
destination.set_revision_history(new_history)
2494
2503
@needs_write_lock
2495
2504
def set_last_revision_info(self, revno, revision_id):
2496
"""Set the last revision of this branch.
2498
The caller is responsible for checking that the revno is correct
2499
for this revision id.
2501
It may be possible to set the branch last revision to an id not
2502
present in the repository. However, branches can also be
2503
configured to check constraints on history, in which case this may not
2505
if not revision_id or not isinstance(revision_id, basestring):
2506
raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2506
2507
revision_id = _mod_revision.ensure_null(revision_id)
2507
# this old format stores the full history, but this api doesn't
2508
# provide it, so we must generate, and might as well check it's
2510
history = self._lefthand_history(revision_id)
2511
if len(history) != revno:
2512
raise AssertionError('%d != %d' % (len(history), revno))
2513
self.set_revision_history(history)
2515
def _gen_revision_history(self):
2516
history = self._transport.get_bytes('revision-history').split('\n')
2517
if history[-1:] == ['']:
2518
# There shouldn't be a trailing newline, but just in case.
2523
def generate_revision_history(self, revision_id, last_rev=None,
2525
"""Create a new revision history that will finish with revision_id.
2527
:param revision_id: the new tip to use.
2528
:param last_rev: The previous last_revision. If not None, then this
2529
must be a ancestory of revision_id, or DivergedBranches is raised.
2530
:param other_branch: The other branch that DivergedBranches should
2531
raise with respect to.
2533
self.set_revision_history(self._lefthand_history(revision_id,
2534
last_rev, other_branch))
2508
old_revno, old_revid = self.last_revision_info()
2509
if self._get_append_revisions_only():
2510
self._check_history_violation(revision_id)
2511
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2512
self._write_last_revision_info(revno, revision_id)
2513
self._clear_cached_state()
2514
self._last_revision_info_cache = revno, revision_id
2515
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2536
2517
def basis_tree(self):
2537
2518
"""See Branch.basis_tree."""
2686
class BzrBranch8(BzrBranch5):
2639
def _read_last_revision_info(self):
2640
revision_string = self._transport.get_bytes('last-revision')
2641
revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
2642
revision_id = cache_utf8.get_cached_utf8(revision_id)
2644
return revno, revision_id
2646
def _write_last_revision_info(self, revno, revision_id):
2647
"""Simply write out the revision id, with no checks.
2649
Use set_last_revision_info to perform this safely.
2651
Does not update the revision_history cache.
2653
revision_id = _mod_revision.ensure_null(revision_id)
2654
out_string = '%d %s\n' % (revno, revision_id)
2655
self._transport.put_bytes('last-revision', out_string,
2656
mode=self.bzrdir._get_file_mode())
2659
class FullHistoryBzrBranch(BzrBranch):
2660
"""Bzr branch which contains the full revision history."""
2663
def set_last_revision_info(self, revno, revision_id):
2664
if not revision_id or not isinstance(revision_id, basestring):
2665
raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2666
revision_id = _mod_revision.ensure_null(revision_id)
2667
# this old format stores the full history, but this api doesn't
2668
# provide it, so we must generate, and might as well check it's
2670
history = self._lefthand_history(revision_id)
2671
if len(history) != revno:
2672
raise AssertionError('%d != %d' % (len(history), revno))
2673
self._set_revision_history(history)
2675
def _read_last_revision_info(self):
2676
rh = self.revision_history()
2679
return (revno, rh[-1])
2681
return (0, _mod_revision.NULL_REVISION)
2683
@deprecated_method(deprecated_in((2, 4, 0)))
2685
def set_revision_history(self, rev_history):
2686
"""See Branch.set_revision_history."""
2687
self._set_revision_history(rev_history)
2689
def _set_revision_history(self, rev_history):
2690
if 'evil' in debug.debug_flags:
2691
mutter_callsite(3, "set_revision_history scales with history.")
2692
check_not_reserved_id = _mod_revision.check_not_reserved_id
2693
for rev_id in rev_history:
2694
check_not_reserved_id(rev_id)
2695
if Branch.hooks['post_change_branch_tip']:
2696
# Don't calculate the last_revision_info() if there are no hooks
2698
old_revno, old_revid = self.last_revision_info()
2699
if len(rev_history) == 0:
2700
revid = _mod_revision.NULL_REVISION
2702
revid = rev_history[-1]
2703
self._run_pre_change_branch_tip_hooks(len(rev_history), revid)
2704
self._write_revision_history(rev_history)
2705
self._clear_cached_state()
2706
self._cache_revision_history(rev_history)
2707
for hook in Branch.hooks['set_rh']:
2708
hook(self, rev_history)
2709
if Branch.hooks['post_change_branch_tip']:
2710
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2712
def _write_revision_history(self, history):
2713
"""Factored out of set_revision_history.
2715
This performs the actual writing to disk.
2716
It is intended to be called by set_revision_history."""
2717
self._transport.put_bytes(
2718
'revision-history', '\n'.join(history),
2719
mode=self.bzrdir._get_file_mode())
2721
def _gen_revision_history(self):
2722
history = self._transport.get_bytes('revision-history').split('\n')
2723
if history[-1:] == ['']:
2724
# There shouldn't be a trailing newline, but just in case.
2728
def _synchronize_history(self, destination, revision_id):
2729
if not isinstance(destination, FullHistoryBzrBranch):
2730
super(BzrBranch, self)._synchronize_history(
2731
destination, revision_id)
2733
if revision_id == _mod_revision.NULL_REVISION:
2736
new_history = self.revision_history()
2737
if revision_id is not None and new_history != []:
2739
new_history = new_history[:new_history.index(revision_id) + 1]
2741
rev = self.repository.get_revision(revision_id)
2742
new_history = rev.get_history(self.repository)[1:]
2743
destination._set_revision_history(new_history)
2746
def generate_revision_history(self, revision_id, last_rev=None,
2748
"""Create a new revision history that will finish with revision_id.
2750
:param revision_id: the new tip to use.
2751
:param last_rev: The previous last_revision. If not None, then this
2752
must be a ancestory of revision_id, or DivergedBranches is raised.
2753
:param other_branch: The other branch that DivergedBranches should
2754
raise with respect to.
2756
self._set_revision_history(self._lefthand_history(revision_id,
2757
last_rev, other_branch))
2760
class BzrBranch5(FullHistoryBzrBranch):
2761
"""A format 5 branch. This supports new features over plain branches.
2763
It has support for a master_branch which is the data for bound branches.
2767
class BzrBranch8(BzrBranch):
2687
2768
"""A branch that stores tree-reference locations."""
2689
2770
def _open_hook(self):
2715
2796
self._last_revision_info_cache = None
2716
2797
self._reference_info = None
2718
def _last_revision_info(self):
2719
revision_string = self._transport.get_bytes('last-revision')
2720
revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
2721
revision_id = cache_utf8.get_cached_utf8(revision_id)
2723
return revno, revision_id
2725
def _write_last_revision_info(self, revno, revision_id):
2726
"""Simply write out the revision id, with no checks.
2728
Use set_last_revision_info to perform this safely.
2730
Does not update the revision_history cache.
2731
Intended to be called by set_last_revision_info and
2732
_write_revision_history.
2734
revision_id = _mod_revision.ensure_null(revision_id)
2735
out_string = '%d %s\n' % (revno, revision_id)
2736
self._transport.put_bytes('last-revision', out_string,
2737
mode=self.bzrdir._get_file_mode())
2740
def set_last_revision_info(self, revno, revision_id):
2741
revision_id = _mod_revision.ensure_null(revision_id)
2742
old_revno, old_revid = self.last_revision_info()
2743
if self._get_append_revisions_only():
2744
self._check_history_violation(revision_id)
2745
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2746
self._write_last_revision_info(revno, revision_id)
2747
self._clear_cached_state()
2748
self._last_revision_info_cache = revno, revision_id
2749
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2751
def _synchronize_history(self, destination, revision_id):
2752
"""Synchronize last revision and revision history between branches.
2754
:see: Branch._synchronize_history
2756
# XXX: The base Branch has a fast implementation of this method based
2757
# on set_last_revision_info, but BzrBranch/BzrBranch5 have a slower one
2758
# that uses set_revision_history. This class inherits from BzrBranch5,
2759
# but wants the fast implementation, so it calls
2760
# Branch._synchronize_history directly.
2761
Branch._synchronize_history(self, destination, revision_id)
2763
2799
def _check_history_violation(self, revision_id):
2764
last_revision = _mod_revision.ensure_null(self.last_revision())
2800
current_revid = self.last_revision()
2801
last_revision = _mod_revision.ensure_null(current_revid)
2765
2802
if _mod_revision.is_null(last_revision):
2767
if last_revision not in self._lefthand_history(revision_id):
2768
raise errors.AppendRevisionsOnlyViolation(self.user_url)
2804
graph = self.repository.get_graph()
2805
for lh_ancestor in graph.iter_lefthand_ancestry(revision_id):
2806
if lh_ancestor == current_revid:
2808
raise errors.AppendRevisionsOnlyViolation(self.user_url)
2770
2810
def _gen_revision_history(self):
2771
2811
"""Generate the revision history from last revision
3223
3212
raise NotImplementedError(self.push)
3215
def copy_content_into(self, revision_id=None):
3216
"""Copy the content of source into target
3218
revision_id: if not None, the revision history in the new branch will
3219
be truncated to end with revision_id.
3221
raise NotImplementedError(self.copy_content_into)
3224
def fetch(self, stop_revision=None, limit=None):
3227
:param stop_revision: Last revision to fetch
3228
:param limit: Optional rough limit of revisions to fetch
3230
raise NotImplementedError(self.fetch)
3226
3233
class GenericInterBranch(InterBranch):
3227
"""InterBranch implementation that uses public Branch functions.
3231
def _get_branch_formats_to_test():
3232
return BranchFormat._default_format, BranchFormat._default_format
3234
def update_revisions(self, stop_revision=None, overwrite=False,
3236
"""See InterBranch.update_revisions()."""
3234
"""InterBranch implementation that uses public Branch functions."""
3237
def is_compatible(klass, source, target):
3238
# GenericBranch uses the public API, so always compatible
3242
def _get_branch_formats_to_test(klass):
3243
return [(format_registry.get_default(), format_registry.get_default())]
3246
def unwrap_format(klass, format):
3247
if isinstance(format, remote.RemoteBranchFormat):
3248
format._ensure_real()
3249
return format._custom_format
3253
def copy_content_into(self, revision_id=None):
3254
"""Copy the content of source into target
3256
revision_id: if not None, the revision history in the new branch will
3257
be truncated to end with revision_id.
3259
self.source.update_references(self.target)
3260
self.source._synchronize_history(self.target, revision_id)
3262
parent = self.source.get_parent()
3263
except errors.InaccessibleParent, e:
3264
mutter('parent was not accessible to copy: %s', e)
3267
self.target.set_parent(parent)
3268
if self.source._push_should_merge_tags():
3269
self.source.tags.merge_to(self.target.tags)
3272
def fetch(self, stop_revision=None, limit=None):
3273
if self.target.base == self.source.base:
3237
3275
self.source.lock_read()
3239
other_revno, other_last_revision = self.source.last_revision_info()
3240
stop_revno = None # unknown
3241
if stop_revision is None:
3242
stop_revision = other_last_revision
3243
if _mod_revision.is_null(stop_revision):
3244
# if there are no commits, we're done.
3246
stop_revno = other_revno
3248
# what's the current last revision, before we fetch [and change it
3250
last_rev = _mod_revision.ensure_null(self.target.last_revision())
3251
# we fetch here so that we don't process data twice in the common
3252
# case of having something to pull, and so that the check for
3253
# already merged can operate on the just fetched graph, which will
3254
# be cached in memory.
3255
self.target.fetch(self.source, stop_revision)
3256
# Check to see if one is an ancestor of the other
3259
graph = self.target.repository.get_graph()
3260
if self.target._check_if_descendant_or_diverged(
3261
stop_revision, last_rev, graph, self.source):
3262
# stop_revision is a descendant of last_rev, but we aren't
3263
# overwriting, so we're done.
3265
if stop_revno is None:
3267
graph = self.target.repository.get_graph()
3268
this_revno, this_last_revision = \
3269
self.target.last_revision_info()
3270
stop_revno = graph.find_distance_to_null(stop_revision,
3271
[(other_last_revision, other_revno),
3272
(this_last_revision, this_revno)])
3273
self.target.set_last_revision_info(stop_revno, stop_revision)
3277
fetch_spec_factory = fetch.FetchSpecFactory()
3278
fetch_spec_factory.source_branch = self.source
3279
fetch_spec_factory.source_branch_stop_revision_id = stop_revision
3280
fetch_spec_factory.source_repo = self.source.repository
3281
fetch_spec_factory.target_repo = self.target.repository
3282
fetch_spec_factory.target_repo_kind = fetch.TargetRepoKinds.PREEXISTING
3283
fetch_spec_factory.limit = limit
3284
fetch_spec = fetch_spec_factory.make_fetch_spec()
3285
return self.target.repository.fetch(self.source.repository,
3286
fetch_spec=fetch_spec)
3275
3288
self.source.unlock()
3291
def _update_revisions(self, stop_revision=None, overwrite=False,
3293
other_revno, other_last_revision = self.source.last_revision_info()
3294
stop_revno = None # unknown
3295
if stop_revision is None:
3296
stop_revision = other_last_revision
3297
if _mod_revision.is_null(stop_revision):
3298
# if there are no commits, we're done.
3300
stop_revno = other_revno
3302
# what's the current last revision, before we fetch [and change it
3304
last_rev = _mod_revision.ensure_null(self.target.last_revision())
3305
# we fetch here so that we don't process data twice in the common
3306
# case of having something to pull, and so that the check for
3307
# already merged can operate on the just fetched graph, which will
3308
# be cached in memory.
3309
self.fetch(stop_revision=stop_revision)
3310
# Check to see if one is an ancestor of the other
3313
graph = self.target.repository.get_graph()
3314
if self.target._check_if_descendant_or_diverged(
3315
stop_revision, last_rev, graph, self.source):
3316
# stop_revision is a descendant of last_rev, but we aren't
3317
# overwriting, so we're done.
3319
if stop_revno is None:
3321
graph = self.target.repository.get_graph()
3322
this_revno, this_last_revision = \
3323
self.target.last_revision_info()
3324
stop_revno = graph.find_distance_to_null(stop_revision,
3325
[(other_last_revision, other_revno),
3326
(this_last_revision, this_revno)])
3327
self.target.set_last_revision_info(stop_revno, stop_revision)
3277
3330
def pull(self, overwrite=False, stop_revision=None,
3331
possible_transports=None, run_hooks=True,
3332
_override_hook_target=None, local=False):
3333
"""Pull from source into self, updating my master if any.
3335
:param run_hooks: Private parameter - if false, this branch
3336
is being called because it's the master of the primary branch,
3337
so it should not run its hooks.
3339
bound_location = self.target.get_bound_location()
3340
if local and not bound_location:
3341
raise errors.LocalRequiresBoundBranch()
3342
master_branch = None
3343
source_is_master = (self.source.user_url == bound_location)
3344
if not local and bound_location and not source_is_master:
3345
# not pulling from master, so we need to update master.
3346
master_branch = self.target.get_master_branch(possible_transports)
3347
master_branch.lock_write()
3350
# pull from source into master.
3351
master_branch.pull(self.source, overwrite, stop_revision,
3353
return self._pull(overwrite,
3354
stop_revision, _hook_master=master_branch,
3355
run_hooks=run_hooks,
3356
_override_hook_target=_override_hook_target,
3357
merge_tags_to_master=not source_is_master)
3360
master_branch.unlock()
3362
def push(self, overwrite=False, stop_revision=None, lossy=False,
3363
_override_hook_source_branch=None):
3364
"""See InterBranch.push.
3366
This is the basic concrete implementation of push()
3368
:param _override_hook_source_branch: If specified, run the hooks
3369
passing this Branch as the source, rather than self. This is for
3370
use of RemoteBranch, where push is delegated to the underlying
3374
raise errors.LossyPushToSameVCS(self.source, self.target)
3375
# TODO: Public option to disable running hooks - should be trivial but
3378
op = cleanup.OperationWithCleanups(self._push_with_bound_branches)
3379
op.add_cleanup(self.source.lock_read().unlock)
3380
op.add_cleanup(self.target.lock_write().unlock)
3381
return op.run(overwrite, stop_revision,
3382
_override_hook_source_branch=_override_hook_source_branch)
3384
def _basic_push(self, overwrite, stop_revision):
3385
"""Basic implementation of push without bound branches or hooks.
3387
Must be called with source read locked and target write locked.
3389
result = BranchPushResult()
3390
result.source_branch = self.source
3391
result.target_branch = self.target
3392
result.old_revno, result.old_revid = self.target.last_revision_info()
3393
self.source.update_references(self.target)
3394
if result.old_revid != stop_revision:
3395
# We assume that during 'push' this repository is closer than
3397
graph = self.source.repository.get_graph(self.target.repository)
3398
self._update_revisions(stop_revision, overwrite=overwrite,
3400
if self.source._push_should_merge_tags():
3401
result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
3403
result.new_revno, result.new_revid = self.target.last_revision_info()
3406
def _push_with_bound_branches(self, operation, overwrite, stop_revision,
3407
_override_hook_source_branch=None):
3408
"""Push from source into target, and into target's master if any.
3411
if _override_hook_source_branch:
3412
result.source_branch = _override_hook_source_branch
3413
for hook in Branch.hooks['post_push']:
3416
bound_location = self.target.get_bound_location()
3417
if bound_location and self.target.base != bound_location:
3418
# there is a master branch.
3420
# XXX: Why the second check? Is it even supported for a branch to
3421
# be bound to itself? -- mbp 20070507
3422
master_branch = self.target.get_master_branch()
3423
master_branch.lock_write()
3424
operation.add_cleanup(master_branch.unlock)
3425
# push into the master from the source branch.
3426
master_inter = InterBranch.get(self.source, master_branch)
3427
master_inter._basic_push(overwrite, stop_revision)
3428
# and push into the target branch from the source. Note that
3429
# we push from the source branch again, because it's considered
3430
# the highest bandwidth repository.
3431
result = self._basic_push(overwrite, stop_revision)
3432
result.master_branch = master_branch
3433
result.local_branch = self.target
3435
master_branch = None
3437
result = self._basic_push(overwrite, stop_revision)
3438
# TODO: Why set master_branch and local_branch if there's no
3439
# binding? Maybe cleaner to just leave them unset? -- mbp
3441
result.master_branch = self.target
3442
result.local_branch = None
3446
def _pull(self, overwrite=False, stop_revision=None,
3278
3447
possible_transports=None, _hook_master=None, run_hooks=True,
3279
_override_hook_target=None, local=False):
3448
_override_hook_target=None, local=False,
3449
merge_tags_to_master=True):
3280
3450
"""See Branch.pull.
3452
This function is the core worker, used by GenericInterBranch.pull to
3453
avoid duplication when pulling source->master and source->local.
3282
3455
:param _hook_master: Private parameter - set the branch to
3283
3456
be supplied as the master to pull hooks.
3284
3457
:param run_hooks: Private parameter - if false, this branch
3285
3458
is being called because it's the master of the primary branch,
3286
3459
so it should not run its hooks.
3460
is being called because it's the master of the primary branch,
3461
so it should not run its hooks.
3287
3462
:param _override_hook_target: Private parameter - set the branch to be
3288
3463
supplied as the target_branch to pull hooks.
3289
3464
:param local: Only update the local branch, and not the bound branch.
3329
3504
self.source.unlock()
3332
def push(self, overwrite=False, stop_revision=None,
3333
_override_hook_source_branch=None):
3334
"""See InterBranch.push.
3336
This is the basic concrete implementation of push()
3338
:param _override_hook_source_branch: If specified, run
3339
the hooks passing this Branch as the source, rather than self.
3340
This is for use of RemoteBranch, where push is delegated to the
3341
underlying vfs-based Branch.
3343
# TODO: Public option to disable running hooks - should be trivial but
3345
self.source.lock_read()
3347
return _run_with_write_locked_target(
3348
self.target, self._push_with_bound_branches, overwrite,
3350
_override_hook_source_branch=_override_hook_source_branch)
3352
self.source.unlock()
3354
def _push_with_bound_branches(self, overwrite, stop_revision,
3355
_override_hook_source_branch=None):
3356
"""Push from source into target, and into target's master if any.
3359
if _override_hook_source_branch:
3360
result.source_branch = _override_hook_source_branch
3361
for hook in Branch.hooks['post_push']:
3364
bound_location = self.target.get_bound_location()
3365
if bound_location and self.target.base != bound_location:
3366
# there is a master branch.
3368
# XXX: Why the second check? Is it even supported for a branch to
3369
# be bound to itself? -- mbp 20070507
3370
master_branch = self.target.get_master_branch()
3371
master_branch.lock_write()
3373
# push into the master from the source branch.
3374
self.source._basic_push(master_branch, overwrite, stop_revision)
3375
# and push into the target branch from the source. Note that we
3376
# push from the source branch again, because its considered the
3377
# highest bandwidth repository.
3378
result = self.source._basic_push(self.target, overwrite,
3380
result.master_branch = master_branch
3381
result.local_branch = self.target
3385
master_branch.unlock()
3388
result = self.source._basic_push(self.target, overwrite,
3390
# TODO: Why set master_branch and local_branch if there's no
3391
# binding? Maybe cleaner to just leave them unset? -- mbp
3393
result.master_branch = self.target
3394
result.local_branch = None
3399
def is_compatible(self, source, target):
3400
# GenericBranch uses the public API, so always compatible
3404
class InterToBranch5(GenericInterBranch):
3407
def _get_branch_formats_to_test():
3408
return BranchFormat._default_format, BzrBranchFormat5()
3410
def pull(self, overwrite=False, stop_revision=None,
3411
possible_transports=None, run_hooks=True,
3412
_override_hook_target=None, local=False):
3413
"""Pull from source into self, updating my master if any.
3415
:param run_hooks: Private parameter - if false, this branch
3416
is being called because it's the master of the primary branch,
3417
so it should not run its hooks.
3419
bound_location = self.target.get_bound_location()
3420
if local and not bound_location:
3421
raise errors.LocalRequiresBoundBranch()
3422
master_branch = None
3423
if not local and bound_location and self.source.user_url != bound_location:
3424
# not pulling from master, so we need to update master.
3425
master_branch = self.target.get_master_branch(possible_transports)
3426
master_branch.lock_write()
3429
# pull from source into master.
3430
master_branch.pull(self.source, overwrite, stop_revision,
3432
return super(InterToBranch5, self).pull(overwrite,
3433
stop_revision, _hook_master=master_branch,
3434
run_hooks=run_hooks,
3435
_override_hook_target=_override_hook_target)
3438
master_branch.unlock()
3441
3508
InterBranch.register_optimiser(GenericInterBranch)
3442
InterBranch.register_optimiser(InterToBranch5)
added
removed
bzrlib/branch.py
