727
746
"""Print `file` to stdout."""
728
747
raise NotImplementedError(self.print_file)
749
@deprecated_method(deprecated_in((2, 4, 0)))
730
750
def set_revision_history(self, rev_history):
731
raise NotImplementedError(self.set_revision_history)
751
"""See Branch.set_revision_history."""
752
self._set_revision_history(rev_history)
755
def _set_revision_history(self, rev_history):
756
if len(rev_history) == 0:
757
revid = _mod_revision.NULL_REVISION
759
revid = rev_history[-1]
760
if rev_history != self._lefthand_history(revid):
761
raise errors.NotLefthandHistory(rev_history)
762
self.set_last_revision_info(len(rev_history), revid)
763
self._cache_revision_history(rev_history)
764
for hook in Branch.hooks['set_rh']:
765
hook(self, rev_history)
768
def set_last_revision_info(self, revno, revision_id):
769
"""Set the last revision of this branch.
771
The caller is responsible for checking that the revno is correct
772
for this revision id.
774
It may be possible to set the branch last revision to an id not
775
present in the repository. However, branches can also be
776
configured to check constraints on history, in which case this may not
779
raise NotImplementedError(self.last_revision_info)
782
def generate_revision_history(self, revision_id, last_rev=None,
784
"""See Branch.generate_revision_history"""
785
# FIXME: This shouldn't have to fetch the entire history
786
history = self._lefthand_history(revision_id, last_rev, other_branch)
788
self.set_last_revision_info(revno, revision_id)
789
self._cache_revision_history(history)
733
791
@needs_write_lock
734
792
def set_parent(self, url):
793
851
old_repository = self.repository
794
852
if len(old_repository._fallback_repositories) != 1:
795
853
raise AssertionError("can't cope with fallback repositories "
796
"of %r" % (self.repository,))
797
# unlock it, including unlocking the fallback
854
"of %r (fallbacks: %r)" % (old_repository,
855
old_repository._fallback_repositories))
856
# Open the new repository object.
857
# Repositories don't offer an interface to remove fallback
858
# repositories today; take the conceptually simpler option and just
859
# reopen it. We reopen it starting from the URL so that we
860
# get a separate connection for RemoteRepositories and can
861
# stream from one of them to the other. This does mean doing
862
# separate SSH connection setup, but unstacking is not a
863
# common operation so it's tolerable.
864
new_bzrdir = bzrdir.BzrDir.open(self.bzrdir.root_transport.base)
865
new_repository = new_bzrdir.find_repository()
866
if new_repository._fallback_repositories:
867
raise AssertionError("didn't expect %r to have "
868
"fallback_repositories"
869
% (self.repository,))
870
# Replace self.repository with the new repository.
871
# Do our best to transfer the lock state (i.e. lock-tokens and
872
# lock count) of self.repository to the new repository.
873
lock_token = old_repository.lock_write().repository_token
874
self.repository = new_repository
875
if isinstance(self, remote.RemoteBranch):
876
# Remote branches can have a second reference to the old
877
# repository that need to be replaced.
878
if self._real_branch is not None:
879
self._real_branch.repository = new_repository
880
self.repository.lock_write(token=lock_token)
881
if lock_token is not None:
882
old_repository.leave_lock_in_place()
798
883
old_repository.unlock()
884
if lock_token is not None:
885
# XXX: self.repository.leave_lock_in_place() before this
886
# function will not be preserved. Fortunately that doesn't
887
# affect the current default format (2a), and would be a
888
# corner-case anyway.
889
# - Andrew Bennetts, 2010/06/30
890
self.repository.dont_leave_lock_in_place()
894
old_repository.unlock()
895
except errors.LockNotHeld:
898
if old_lock_count == 0:
899
raise AssertionError(
900
'old_repository should have been locked at least once.')
901
for i in range(old_lock_count-1):
902
self.repository.lock_write()
903
# Fetch from the old repository into the new.
799
904
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
906
# XXX: If you unstack a branch while it has a working tree
820
907
# with a pending merge, the pending-merged revisions will no
821
908
# 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(),
910
tags_to_fetch = set(self.tags.get_reverse_tag_dict())
911
except errors.TagsNotSupported:
912
tags_to_fetch = set()
913
fetch_spec = _mod_graph.NotInOtherForRevs(self.repository,
914
old_repository, required_ids=[self.last_revision()],
915
if_present_ids=tags_to_fetch, find_ghosts=True).execute()
916
self.repository.fetch(old_repository, fetch_spec=fetch_spec)
830
918
old_repository.unlock()
928
1022
:return: A tuple (revno, revision_id).
930
1024
if self._last_revision_info_cache is None:
931
self._last_revision_info_cache = self._last_revision_info()
1025
self._last_revision_info_cache = self._read_last_revision_info()
932
1026
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,
1028
def _read_last_revision_info(self):
1029
raise NotImplementedError(self._read_last_revision_info)
1031
@deprecated_method(deprecated_in((2, 4, 0)))
981
1032
def import_last_revision_info(self, source_repo, revno, revid):
982
1033
"""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
1035
:param source_repo: Source repository to optionally fetch from
988
1036
:param revno: Revision number of the new tip
989
1037
:param revid: Revision id of the new tip
1573
1662
for hook in hooks:
1576
def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
1577
lock_type='metadir', set_format=True):
1578
"""Initialize a branch in a bzrdir, with specified files
1580
:param a_bzrdir: The bzrdir to initialize the branch in
1581
:param utf8_files: The files to create as a list of
1582
(filename, content) tuples
1583
:param name: Name of colocated branch to create, if any
1584
:param set_format: If True, set the format with
1585
self.get_format_string. (BzrBranch4 has its format set
1587
:return: a branch in this format
1589
mutter('creating branch %r in %s', self, a_bzrdir.user_url)
1590
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1592
'metadir': ('lock', lockdir.LockDir),
1593
'branch4': ('branch-lock', lockable_files.TransportLock),
1595
lock_name, lock_class = lock_map[lock_type]
1596
control_files = lockable_files.LockableFiles(branch_transport,
1597
lock_name, lock_class)
1598
control_files.create_lock()
1600
control_files.lock_write()
1601
except errors.LockContention:
1602
if lock_type != 'branch4':
1608
utf8_files += [('format', self.get_format_string())]
1610
for (filename, content) in utf8_files:
1611
branch_transport.put_bytes(
1613
mode=a_bzrdir._get_file_mode())
1616
control_files.unlock()
1617
branch = self.open(a_bzrdir, name, _found=True)
1618
self._run_post_branch_init_hooks(a_bzrdir, name, branch)
1621
def initialize(self, a_bzrdir, name=None):
1665
def initialize(self, a_bzrdir, name=None, repository=None):
1622
1666
"""Create a branch of this format in a_bzrdir.
1624
1668
:param name: Name of the colocated branch to create.
1715
1796
These are all empty initially, because by default nothing should get
1718
Hooks.__init__(self)
1719
self.create_hook(HookPoint('set_rh',
1799
Hooks.__init__(self, "bzrlib.branch", "Branch.hooks")
1800
self.add_hook('set_rh',
1720
1801
"Invoked whenever the revision history has been set via "
1721
1802
"set_revision_history. The api signature is (branch, "
1722
1803
"revision_history), and the branch will be write-locked. "
1723
1804
"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',
1805
"hook to use is Branch.post_change_branch_tip.", (0, 15))
1806
self.add_hook('open',
1726
1807
"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',
1808
"branch is opened.", (1, 8))
1809
self.add_hook('post_push',
1729
1810
"Called after a push operation completes. post_push is called "
1730
1811
"with a bzrlib.branch.BranchPushResult object and only runs in the "
1731
"bzr client.", (0, 15), None))
1732
self.create_hook(HookPoint('post_pull',
1812
"bzr client.", (0, 15))
1813
self.add_hook('post_pull',
1733
1814
"Called after a pull operation completes. post_pull is called "
1734
1815
"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 "
1816
"bzr client.", (0, 15))
1817
self.add_hook('pre_commit',
1818
"Called after a commit is calculated but before it is "
1738
1819
"completed. pre_commit is called with (local, master, old_revno, "
1739
1820
"old_revid, future_revno, future_revid, tree_delta, future_tree"
1740
1821
"). old_revid is NULL_REVISION for the first commit to a branch, "
1742
1823
"basis revision. hooks MUST NOT modify this delta. "
1743
1824
" future_tree is an in-memory tree obtained from "
1744
1825
"CommitBuilder.revision_tree() and hooks MUST NOT modify this "
1745
"tree.", (0,91), None))
1746
self.create_hook(HookPoint('post_commit',
1827
self.add_hook('post_commit',
1747
1828
"Called in the bzr client after a commit has completed. "
1748
1829
"post_commit is called with (local, master, old_revno, old_revid, "
1749
1830
"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',
1831
"commit to a branch.", (0, 15))
1832
self.add_hook('post_uncommit',
1752
1833
"Called in the bzr client after an uncommit completes. "
1753
1834
"post_uncommit is called with (local, master, old_revno, "
1754
1835
"old_revid, new_revno, new_revid) where local is the local branch "
1755
1836
"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',
1837
"receives new_revno of 0, new_revid of None.", (0, 15))
1838
self.add_hook('pre_change_branch_tip',
1758
1839
"Called in bzr client and server before a change to the tip of a "
1759
1840
"branch is made. pre_change_branch_tip is called with a "
1760
1841
"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',
1842
"commit, uncommit will all trigger this hook.", (1, 6))
1843
self.add_hook('post_change_branch_tip',
1763
1844
"Called in bzr client and server after a change to the tip of a "
1764
1845
"branch is made. post_change_branch_tip is called with a "
1765
1846
"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',
1847
"commit, uncommit will all trigger this hook.", (1, 4))
1848
self.add_hook('transform_fallback_location',
1768
1849
"Called when a stacked branch is activating its fallback "
1769
1850
"locations. transform_fallback_location is called with (branch, "
1770
1851
"url), and should return a new url. Returning the same url "
1775
1856
"fallback locations have not been activated. When there are "
1776
1857
"multiple hooks installed for transform_fallback_location, "
1777
1858
"all are called with the url returned from the previous hook."
1778
"The order is however undefined.", (1, 9), None))
1779
self.create_hook(HookPoint('automatic_tag_name',
1780
"Called to determine an automatic tag name for a revision."
1859
"The order is however undefined.", (1, 9))
1860
self.add_hook('automatic_tag_name',
1861
"Called to determine an automatic tag name for a revision. "
1781
1862
"automatic_tag_name is called with (branch, revision_id) and "
1782
1863
"should return a tag name or None if no tag name could be "
1783
1864
"determined. The first non-None tag name returned will be used.",
1785
self.create_hook(HookPoint('post_branch_init',
1866
self.add_hook('post_branch_init',
1786
1867
"Called after new branch initialization completes. "
1787
1868
"post_branch_init is called with a "
1788
1869
"bzrlib.branch.BranchInitHookParams. "
1789
1870
"Note that init, branch and checkout (both heavyweight and "
1790
"lightweight) will all trigger this hook.", (2, 2), None))
1791
self.create_hook(HookPoint('post_switch',
1871
"lightweight) will all trigger this hook.", (2, 2))
1872
self.add_hook('post_switch',
1792
1873
"Called after a checkout switches branch. "
1793
1874
"post_switch is called with a "
1794
"bzrlib.branch.SwitchHookParams.", (2, 2), None))
1875
"bzrlib.branch.SwitchHookParams.", (2, 2))
2428
2511
"""See Branch.print_file."""
2429
2512
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
2514
@needs_write_lock
2495
2515
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
2516
if not revision_id or not isinstance(revision_id, basestring):
2517
raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2506
2518
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))
2519
old_revno, old_revid = self.last_revision_info()
2520
if self._get_append_revisions_only():
2521
self._check_history_violation(revision_id)
2522
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2523
self._write_last_revision_info(revno, revision_id)
2524
self._clear_cached_state()
2525
self._last_revision_info_cache = revno, revision_id
2526
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2536
2528
def basis_tree(self):
2537
2529
"""See Branch.basis_tree."""
2686
class BzrBranch8(BzrBranch5):
2650
def _read_last_revision_info(self):
2651
revision_string = self._transport.get_bytes('last-revision')
2652
revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
2653
revision_id = cache_utf8.get_cached_utf8(revision_id)
2655
return revno, revision_id
2657
def _write_last_revision_info(self, revno, revision_id):
2658
"""Simply write out the revision id, with no checks.
2660
Use set_last_revision_info to perform this safely.
2662
Does not update the revision_history cache.
2664
revision_id = _mod_revision.ensure_null(revision_id)
2665
out_string = '%d %s\n' % (revno, revision_id)
2666
self._transport.put_bytes('last-revision', out_string,
2667
mode=self.bzrdir._get_file_mode())
2670
class FullHistoryBzrBranch(BzrBranch):
2671
"""Bzr branch which contains the full revision history."""
2674
def set_last_revision_info(self, revno, revision_id):
2675
if not revision_id or not isinstance(revision_id, basestring):
2676
raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2677
revision_id = _mod_revision.ensure_null(revision_id)
2678
# this old format stores the full history, but this api doesn't
2679
# provide it, so we must generate, and might as well check it's
2681
history = self._lefthand_history(revision_id)
2682
if len(history) != revno:
2683
raise AssertionError('%d != %d' % (len(history), revno))
2684
self._set_revision_history(history)
2686
def _read_last_revision_info(self):
2687
rh = self.revision_history()
2690
return (revno, rh[-1])
2692
return (0, _mod_revision.NULL_REVISION)
2694
@deprecated_method(deprecated_in((2, 4, 0)))
2696
def set_revision_history(self, rev_history):
2697
"""See Branch.set_revision_history."""
2698
self._set_revision_history(rev_history)
2700
def _set_revision_history(self, rev_history):
2701
if 'evil' in debug.debug_flags:
2702
mutter_callsite(3, "set_revision_history scales with history.")
2703
check_not_reserved_id = _mod_revision.check_not_reserved_id
2704
for rev_id in rev_history:
2705
check_not_reserved_id(rev_id)
2706
if Branch.hooks['post_change_branch_tip']:
2707
# Don't calculate the last_revision_info() if there are no hooks
2709
old_revno, old_revid = self.last_revision_info()
2710
if len(rev_history) == 0:
2711
revid = _mod_revision.NULL_REVISION
2713
revid = rev_history[-1]
2714
self._run_pre_change_branch_tip_hooks(len(rev_history), revid)
2715
self._write_revision_history(rev_history)
2716
self._clear_cached_state()
2717
self._cache_revision_history(rev_history)
2718
for hook in Branch.hooks['set_rh']:
2719
hook(self, rev_history)
2720
if Branch.hooks['post_change_branch_tip']:
2721
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2723
def _write_revision_history(self, history):
2724
"""Factored out of set_revision_history.
2726
This performs the actual writing to disk.
2727
It is intended to be called by set_revision_history."""
2728
self._transport.put_bytes(
2729
'revision-history', '\n'.join(history),
2730
mode=self.bzrdir._get_file_mode())
2732
def _gen_revision_history(self):
2733
history = self._transport.get_bytes('revision-history').split('\n')
2734
if history[-1:] == ['']:
2735
# There shouldn't be a trailing newline, but just in case.
2739
def _synchronize_history(self, destination, revision_id):
2740
if not isinstance(destination, FullHistoryBzrBranch):
2741
super(BzrBranch, self)._synchronize_history(
2742
destination, revision_id)
2744
if revision_id == _mod_revision.NULL_REVISION:
2747
new_history = self.revision_history()
2748
if revision_id is not None and new_history != []:
2750
new_history = new_history[:new_history.index(revision_id) + 1]
2752
rev = self.repository.get_revision(revision_id)
2753
new_history = rev.get_history(self.repository)[1:]
2754
destination._set_revision_history(new_history)
2757
def generate_revision_history(self, revision_id, last_rev=None,
2759
"""Create a new revision history that will finish with revision_id.
2761
:param revision_id: the new tip to use.
2762
:param last_rev: The previous last_revision. If not None, then this
2763
must be a ancestory of revision_id, or DivergedBranches is raised.
2764
:param other_branch: The other branch that DivergedBranches should
2765
raise with respect to.
2767
self._set_revision_history(self._lefthand_history(revision_id,
2768
last_rev, other_branch))
2771
class BzrBranch5(FullHistoryBzrBranch):
2772
"""A format 5 branch. This supports new features over plain branches.
2774
It has support for a master_branch which is the data for bound branches.
2778
class BzrBranch8(BzrBranch):
2687
2779
"""A branch that stores tree-reference locations."""
2689
2781
def _open_hook(self):
2715
2807
self._last_revision_info_cache = None
2716
2808
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
2810
def _check_history_violation(self, revision_id):
2764
2811
last_revision = _mod_revision.ensure_null(self.last_revision())
2765
2812
if _mod_revision.is_null(last_revision):
3223
3252
raise NotImplementedError(self.push)
3255
def copy_content_into(self, revision_id=None):
3256
"""Copy the content of source into target
3258
revision_id: if not None, the revision history in the new branch will
3259
be truncated to end with revision_id.
3261
raise NotImplementedError(self.copy_content_into)
3264
def fetch(self, stop_revision=None):
3267
:param stop_revision: Last revision to fetch
3269
raise NotImplementedError(self.fetch)
3226
3272
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()."""
3273
"""InterBranch implementation that uses public Branch functions."""
3276
def is_compatible(klass, source, target):
3277
# GenericBranch uses the public API, so always compatible
3281
def _get_branch_formats_to_test(klass):
3282
return [(format_registry.get_default(), format_registry.get_default())]
3285
def unwrap_format(klass, format):
3286
if isinstance(format, remote.RemoteBranchFormat):
3287
format._ensure_real()
3288
return format._custom_format
3292
def copy_content_into(self, revision_id=None):
3293
"""Copy the content of source into target
3295
revision_id: if not None, the revision history in the new branch will
3296
be truncated to end with revision_id.
3298
self.source.update_references(self.target)
3299
self.source._synchronize_history(self.target, revision_id)
3301
parent = self.source.get_parent()
3302
except errors.InaccessibleParent, e:
3303
mutter('parent was not accessible to copy: %s', e)
3306
self.target.set_parent(parent)
3307
if self.source._push_should_merge_tags():
3308
self.source.tags.merge_to(self.target.tags)
3311
def fetch(self, stop_revision=None):
3312
if self.target.base == self.source.base:
3237
3314
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)
3316
fetch_spec_factory = fetch.FetchSpecFactory()
3317
fetch_spec_factory.source_branch = self.source
3318
fetch_spec_factory.source_branch_stop_revision_id = stop_revision
3319
fetch_spec_factory.source_repo = self.source.repository
3320
fetch_spec_factory.target_repo = self.target.repository
3321
fetch_spec_factory.target_repo_kind = fetch.TargetRepoKinds.PREEXISTING
3322
fetch_spec = fetch_spec_factory.make_fetch_spec()
3323
return self.target.repository.fetch(self.source.repository,
3324
fetch_spec=fetch_spec)
3275
3326
self.source.unlock()
3329
def _update_revisions(self, stop_revision=None, overwrite=False,
3331
other_revno, other_last_revision = self.source.last_revision_info()
3332
stop_revno = None # unknown
3333
if stop_revision is None:
3334
stop_revision = other_last_revision
3335
if _mod_revision.is_null(stop_revision):
3336
# if there are no commits, we're done.
3338
stop_revno = other_revno
3340
# what's the current last revision, before we fetch [and change it
3342
last_rev = _mod_revision.ensure_null(self.target.last_revision())
3343
# we fetch here so that we don't process data twice in the common
3344
# case of having something to pull, and so that the check for
3345
# already merged can operate on the just fetched graph, which will
3346
# be cached in memory.
3347
self.fetch(stop_revision=stop_revision)
3348
# Check to see if one is an ancestor of the other
3351
graph = self.target.repository.get_graph()
3352
if self.target._check_if_descendant_or_diverged(
3353
stop_revision, last_rev, graph, self.source):
3354
# stop_revision is a descendant of last_rev, but we aren't
3355
# overwriting, so we're done.
3357
if stop_revno is None:
3359
graph = self.target.repository.get_graph()
3360
this_revno, this_last_revision = \
3361
self.target.last_revision_info()
3362
stop_revno = graph.find_distance_to_null(stop_revision,
3363
[(other_last_revision, other_revno),
3364
(this_last_revision, this_revno)])
3365
self.target.set_last_revision_info(stop_revno, stop_revision)
3277
3368
def pull(self, overwrite=False, stop_revision=None,
3278
possible_transports=None, _hook_master=None, run_hooks=True,
3369
possible_transports=None, run_hooks=True,
3279
3370
_override_hook_target=None, local=False):
3371
"""Pull from source into self, updating my master if any.
3282
:param _hook_master: Private parameter - set the branch to
3283
be supplied as the master to pull hooks.
3284
3373
:param run_hooks: Private parameter - if false, this branch
3285
3374
is being called because it's the master of the primary branch,
3286
3375
so it should not run its hooks.
3287
:param _override_hook_target: Private parameter - set the branch to be
3288
supplied as the target_branch to pull hooks.
3289
:param local: Only update the local branch, and not the bound branch.
3291
# This type of branch can't be bound.
3377
bound_location = self.target.get_bound_location()
3378
if local and not bound_location:
3293
3379
raise errors.LocalRequiresBoundBranch()
3294
result = PullResult()
3295
result.source_branch = self.source
3296
if _override_hook_target is None:
3297
result.target_branch = self.target
3299
result.target_branch = _override_hook_target
3300
self.source.lock_read()
3380
master_branch = None
3381
source_is_master = (self.source.user_url == bound_location)
3382
if not local and bound_location and not source_is_master:
3383
# not pulling from master, so we need to update master.
3384
master_branch = self.target.get_master_branch(possible_transports)
3385
master_branch.lock_write()
3302
# We assume that during 'pull' the target repository is closer than
3304
self.source.update_references(self.target)
3305
graph = self.target.repository.get_graph(self.source.repository)
3306
# TODO: Branch formats should have a flag that indicates
3307
# that revno's are expensive, and pull() should honor that flag.
3309
result.old_revno, result.old_revid = \
3310
self.target.last_revision_info()
3311
self.target.update_revisions(self.source, stop_revision,
3312
overwrite=overwrite, graph=graph)
3313
# TODO: The old revid should be specified when merging tags,
3314
# so a tags implementation that versions tags can only
3315
# pull in the most recent changes. -- JRV20090506
3316
result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
3318
result.new_revno, result.new_revid = self.target.last_revision_info()
3320
result.master_branch = _hook_master
3321
result.local_branch = result.target_branch
3323
result.master_branch = result.target_branch
3324
result.local_branch = None
3326
for hook in Branch.hooks['post_pull']:
3388
# pull from source into master.
3389
master_branch.pull(self.source, overwrite, stop_revision,
3391
return self._pull(overwrite,
3392
stop_revision, _hook_master=master_branch,
3393
run_hooks=run_hooks,
3394
_override_hook_target=_override_hook_target,
3395
merge_tags_to_master=not source_is_master)
3329
self.source.unlock()
3398
master_branch.unlock()
3332
3400
def push(self, overwrite=False, stop_revision=None,
3333
3401
_override_hook_source_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.
3487
def _pull(self, overwrite=False, stop_revision=None,
3488
possible_transports=None, _hook_master=None, run_hooks=True,
3489
_override_hook_target=None, local=False,
3490
merge_tags_to_master=True):
3493
This function is the core worker, used by GenericInterBranch.pull to
3494
avoid duplication when pulling source->master and source->local.
3496
:param _hook_master: Private parameter - set the branch to
3497
be supplied as the master to pull hooks.
3415
3498
:param run_hooks: Private parameter - if false, this branch
3416
3499
is being called because it's the master of the primary branch,
3417
3500
so it should not run its hooks.
3501
is being called because it's the master of the primary branch,
3502
so it should not run its hooks.
3503
:param _override_hook_target: Private parameter - set the branch to be
3504
supplied as the target_branch to pull hooks.
3505
:param local: Only update the local branch, and not the bound branch.
3419
bound_location = self.target.get_bound_location()
3420
if local and not bound_location:
3507
# This type of branch can't be bound.
3421
3509
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()
3510
result = PullResult()
3511
result.source_branch = self.source
3512
if _override_hook_target is None:
3513
result.target_branch = self.target
3515
result.target_branch = _override_hook_target
3516
self.source.lock_read()
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)
3518
# We assume that during 'pull' the target repository is closer than
3520
self.source.update_references(self.target)
3521
graph = self.target.repository.get_graph(self.source.repository)
3522
# TODO: Branch formats should have a flag that indicates
3523
# that revno's are expensive, and pull() should honor that flag.
3525
result.old_revno, result.old_revid = \
3526
self.target.last_revision_info()
3527
self._update_revisions(stop_revision, overwrite=overwrite,
3529
# TODO: The old revid should be specified when merging tags,
3530
# so a tags implementation that versions tags can only
3531
# pull in the most recent changes. -- JRV20090506
3532
result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
3533
overwrite, ignore_master=not merge_tags_to_master)
3534
result.new_revno, result.new_revid = self.target.last_revision_info()
3536
result.master_branch = _hook_master
3537
result.local_branch = result.target_branch
3539
result.master_branch = result.target_branch
3540
result.local_branch = None
3542
for hook in Branch.hooks['post_pull']:
3438
master_branch.unlock()
3545
self.source.unlock()
3441
3549
InterBranch.register_optimiser(GenericInterBranch)
3442
InterBranch.register_optimiser(InterToBranch5)
added
removed
bzrlib/branch.py
