662
670
raise errors.UnsupportedOperation(self.get_reference_info, self)
664
672
@needs_write_lock
665
def fetch(self, from_branch, last_revision=None, pb=None):
673
def fetch(self, from_branch, last_revision=None, limit=None):
666
674
"""Copy revisions from from_branch into this branch.
668
676
:param from_branch: Where to copy from.
669
677
:param last_revision: What revision to stop at (None for at the end
671
:param pb: An optional progress bar to use.
679
:param limit: Optional rough limit of revisions to fetch
674
if self.base == from_branch.base:
677
symbol_versioning.warn(
678
symbol_versioning.deprecated_in((1, 14, 0))
679
% "pb parameter to fetch()")
680
from_branch.lock_read()
682
if last_revision is None:
683
last_revision = from_branch.last_revision()
684
last_revision = _mod_revision.ensure_null(last_revision)
685
return self.repository.fetch(from_branch.repository,
686
revision_id=last_revision,
682
return InterBranch.get(from_branch, self).fetch(last_revision, limit=limit)
691
684
def get_bound_location(self):
692
685
"""Return the URL of the branch we are bound to.
752
748
"""Print `file` to stdout."""
753
749
raise NotImplementedError(self.print_file)
751
@deprecated_method(deprecated_in((2, 4, 0)))
755
752
def set_revision_history(self, rev_history):
756
raise NotImplementedError(self.set_revision_history)
753
"""See Branch.set_revision_history."""
754
self._set_revision_history(rev_history)
757
def _set_revision_history(self, rev_history):
758
if len(rev_history) == 0:
759
revid = _mod_revision.NULL_REVISION
761
revid = rev_history[-1]
762
if rev_history != self._lefthand_history(revid):
763
raise errors.NotLefthandHistory(rev_history)
764
self.set_last_revision_info(len(rev_history), revid)
765
self._cache_revision_history(rev_history)
766
for hook in Branch.hooks['set_rh']:
767
hook(self, rev_history)
770
def set_last_revision_info(self, revno, revision_id):
771
"""Set the last revision of this branch.
773
The caller is responsible for checking that the revno is correct
774
for this revision id.
776
It may be possible to set the branch last revision to an id not
777
present in the repository. However, branches can also be
778
configured to check constraints on history, in which case this may not
781
raise NotImplementedError(self.set_last_revision_info)
784
def generate_revision_history(self, revision_id, last_rev=None,
786
"""See Branch.generate_revision_history"""
787
graph = self.repository.get_graph()
788
known_revision_ids = [
789
self.last_revision_info(),
790
(_mod_revision.NULL_REVISION, 0),
792
if last_rev is not None:
793
if not graph.is_ancestor(last_rev, revision_id):
794
# our previous tip is not merged into stop_revision
795
raise errors.DivergedBranches(self, other_branch)
796
revno = graph.find_distance_to_null(revision_id, known_revision_ids)
797
self.set_last_revision_info(revno, revision_id)
758
799
@needs_write_lock
759
800
def set_parent(self, url):
873
914
# XXX: If you unstack a branch while it has a working tree
874
915
# with a pending merge, the pending-merged revisions will no
875
916
# longer be present. You can (probably) revert and remerge.
877
# XXX: This only fetches up to the tip of the repository; it
878
# doesn't bring across any tags. That's fairly consistent
879
# with how branch works, but perhaps not ideal.
880
self.repository.fetch(old_repository,
881
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)
884
926
old_repository.unlock()
988
1031
:return: A tuple (revno, revision_id).
990
1033
if self._last_revision_info_cache is None:
991
self._last_revision_info_cache = self._last_revision_info()
1034
self._last_revision_info_cache = self._read_last_revision_info()
992
1035
return self._last_revision_info_cache
994
def _last_revision_info(self):
995
rh = self.revision_history()
998
return (revno, rh[-1])
1000
return (0, _mod_revision.NULL_REVISION)
1002
@deprecated_method(deprecated_in((1, 6, 0)))
1003
def missing_revisions(self, other, stop_revision=None):
1004
"""Return a list of new revisions that would perfectly fit.
1006
If self and other have not diverged, return a list of the revisions
1007
present in other, but missing from self.
1009
self_history = self.revision_history()
1010
self_len = len(self_history)
1011
other_history = other.revision_history()
1012
other_len = len(other_history)
1013
common_index = min(self_len, other_len) -1
1014
if common_index >= 0 and \
1015
self_history[common_index] != other_history[common_index]:
1016
raise errors.DivergedBranches(self, other)
1018
if stop_revision is None:
1019
stop_revision = other_len
1021
if stop_revision > other_len:
1022
raise errors.NoSuchRevision(self, stop_revision)
1023
return other_history[self_len:stop_revision]
1025
def update_revisions(self, other, stop_revision=None, overwrite=False,
1027
"""Pull in new perfect-fit revisions.
1029
:param other: Another Branch to pull from
1030
:param stop_revision: Updated until the given revision
1031
:param overwrite: Always set the branch pointer, rather than checking
1032
to see if it is a proper descendant.
1033
:param graph: A Graph object that can be used to query history
1034
information. This can be None.
1037
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)))
1040
1041
def import_last_revision_info(self, source_repo, revno, revid):
1041
1042
"""Set the last revision info, importing from another repo if necessary.
1043
This is used by the bound branch code to upload a revision to
1044
the master branch first before updating the tip of the local branch.
1046
1044
:param source_repo: Source repository to optionally fetch from
1047
1045
:param revno: Revision number of the new tip
1048
1046
:param revid: Revision id of the new tip
1051
1049
self.repository.fetch(source_repo, revision_id=revid)
1052
1050
self.set_last_revision_info(revno, revid)
1052
def import_last_revision_info_and_tags(self, source, revno, revid,
1054
"""Set the last revision info, importing from another repo if necessary.
1056
This is used by the bound branch code to upload a revision to
1057
the master branch first before updating the tip of the local branch.
1058
Revisions referenced by source's tags are also transferred.
1060
:param source: Source branch to optionally fetch from
1061
:param revno: Revision number of the new tip
1062
:param revid: Revision id of the new tip
1063
:param lossy: Whether to discard metadata that can not be
1064
natively represented
1065
:return: Tuple with the new revision number and revision id
1066
(should only be different from the arguments when lossy=True)
1068
if not self.repository.has_same_location(source.repository):
1069
self.fetch(source, revid)
1070
self.set_last_revision_info(revno, revid)
1071
return (revno, revid)
1054
1073
def revision_id_to_revno(self, revision_id):
1055
1074
"""Given a revision id, return its revno"""
1056
1075
if _mod_revision.is_null(revision_id):
1088
1107
stop_revision=stop_revision,
1089
1108
possible_transports=possible_transports, *args, **kwargs)
1091
def push(self, target, overwrite=False, stop_revision=None, *args,
1110
def push(self, target, overwrite=False, stop_revision=None, lossy=False,
1093
1112
"""Mirror this branch into target.
1095
1114
This branch is considered to be 'local', having low latency.
1097
1116
return InterBranch.get(self, target).push(overwrite, stop_revision,
1100
def lossy_push(self, target, stop_revision=None):
1101
"""Push deltas into another branch.
1103
:note: This does not, like push, retain the revision ids from
1104
the source branch and will, rather than adding bzr-specific
1105
metadata, push only those semantics of the revision that can be
1106
natively represented by this branch' VCS.
1108
:param target: Target branch
1109
:param stop_revision: Revision to push, defaults to last revision.
1110
:return: BranchPushResult with an extra member revidmap:
1111
A dictionary mapping revision ids from the target branch
1112
to new revision ids in the target branch, for each
1113
revision that was pushed.
1115
inter = InterBranch.get(self, target)
1116
lossy_push = getattr(inter, "lossy_push", None)
1117
if lossy_push is None:
1118
raise errors.LossyPushToSameVCS(self, target)
1119
return lossy_push(stop_revision)
1117
lossy, *args, **kwargs)
1121
1119
def basis_tree(self):
1122
1120
"""Return `Tree` object for last revision."""
1531
1534
raise AssertionError("invalid heads: %r" % (heads,))
1534
class BranchFormat(object):
1536
def heads_to_fetch(self):
1537
"""Return the heads that must and that should be fetched to copy this
1538
branch into another repo.
1540
:returns: a 2-tuple of (must_fetch, if_present_fetch). must_fetch is a
1541
set of heads that must be fetched. if_present_fetch is a set of
1542
heads that must be fetched if present, but no error is necessary if
1543
they are not present.
1545
# For bzr native formats must_fetch is just the tip, and if_present_fetch
1547
must_fetch = set([self.last_revision()])
1549
if_present_fetch = set(self.tags.get_reverse_tag_dict())
1550
except errors.TagsNotSupported:
1551
if_present_fetch = set()
1552
must_fetch.discard(_mod_revision.NULL_REVISION)
1553
if_present_fetch.discard(_mod_revision.NULL_REVISION)
1554
return must_fetch, if_present_fetch
1557
class BranchFormat(controldir.ControlComponentFormat):
1535
1558
"""An encapsulation of the initialization and open routines for a format.
1537
1560
Formats provide three things:
1570
1587
transport = a_bzrdir.get_branch_transport(None, name=name)
1571
1588
format_string = transport.get_bytes("format")
1572
format = klass._formats[format_string]
1573
if isinstance(format, MetaDirBranchFormatFactory):
1589
return format_registry.get(format_string)
1576
1590
except errors.NoSuchFile:
1577
1591
raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1578
1592
except KeyError:
1579
1593
raise errors.UnknownFormatError(format=format_string, kind='branch')
1596
@deprecated_method(deprecated_in((2, 4, 0)))
1582
1597
def get_default_format(klass):
1583
1598
"""Return the current default format."""
1584
return klass._default_format
1599
return format_registry.get_default()
1602
@deprecated_method(deprecated_in((2, 4, 0)))
1587
1603
def get_formats(klass):
1588
1604
"""Get all the known formats.
1590
1606
Warning: This triggers a load of all lazy registered formats: do not
1591
1607
use except when that is desireed.
1594
for fmt in klass._formats.values():
1595
if isinstance(fmt, MetaDirBranchFormatFactory):
1609
return format_registry._get_all()
1600
1611
def get_reference(self, a_bzrdir, name=None):
1601
1612
"""Get the target reference of the branch in a_bzrdir.
1640
1651
for hook in hooks:
1643
def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
1644
repository=None, lock_type='metadir',
1646
"""Initialize a branch in a bzrdir, with specified files
1648
:param a_bzrdir: The bzrdir to initialize the branch in
1649
:param utf8_files: The files to create as a list of
1650
(filename, content) tuples
1651
:param name: Name of colocated branch to create, if any
1652
:param set_format: If True, set the format with
1653
self.get_format_string. (BzrBranch4 has its format set
1655
:return: a branch in this format
1657
mutter('creating branch %r in %s', self, a_bzrdir.user_url)
1658
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1660
'metadir': ('lock', lockdir.LockDir),
1661
'branch4': ('branch-lock', lockable_files.TransportLock),
1663
lock_name, lock_class = lock_map[lock_type]
1664
control_files = lockable_files.LockableFiles(branch_transport,
1665
lock_name, lock_class)
1666
control_files.create_lock()
1668
control_files.lock_write()
1669
except errors.LockContention:
1670
if lock_type != 'branch4':
1676
utf8_files += [('format', self.get_format_string())]
1678
for (filename, content) in utf8_files:
1679
branch_transport.put_bytes(
1681
mode=a_bzrdir._get_file_mode())
1684
control_files.unlock()
1685
branch = self.open(a_bzrdir, name, _found=True,
1686
found_repository=repository)
1687
self._run_post_branch_init_hooks(a_bzrdir, name, branch)
1690
1654
def initialize(self, a_bzrdir, name=None, repository=None):
1691
1655
"""Create a branch of this format in a_bzrdir.
1741
1705
raise NotImplementedError(self.open)
1708
@deprecated_method(deprecated_in((2, 4, 0)))
1744
1709
def register_format(klass, format):
1745
1710
"""Register a metadir format.
1747
1712
See MetaDirBranchFormatFactory for the ability to register a format
1748
1713
without loading the code the format needs until it is actually used.
1750
klass._formats[format.get_format_string()] = format
1751
# Metadir formats have a network name of their format string, and get
1752
# registered as factories.
1753
if isinstance(format, MetaDirBranchFormatFactory):
1754
network_format_registry.register(format.get_format_string(), format)
1756
network_format_registry.register(format.get_format_string(),
1715
format_registry.register(format)
1718
@deprecated_method(deprecated_in((2, 4, 0)))
1760
1719
def set_default_format(klass, format):
1761
klass._default_format = format
1720
format_registry.set_default(format)
1763
1722
def supports_set_append_revisions_only(self):
1764
1723
"""True if this format supports set_append_revisions_only."""
1821
1785
These are all empty initially, because by default nothing should get
1824
Hooks.__init__(self)
1825
self.create_hook(HookPoint('set_rh',
1788
Hooks.__init__(self, "bzrlib.branch", "Branch.hooks")
1789
self.add_hook('set_rh',
1826
1790
"Invoked whenever the revision history has been set via "
1827
1791
"set_revision_history. The api signature is (branch, "
1828
1792
"revision_history), and the branch will be write-locked. "
1829
1793
"The set_rh hook can be expensive for bzr to trigger, a better "
1830
"hook to use is Branch.post_change_branch_tip.", (0, 15), None))
1831
self.create_hook(HookPoint('open',
1794
"hook to use is Branch.post_change_branch_tip.", (0, 15))
1795
self.add_hook('open',
1832
1796
"Called with the Branch object that has been opened after a "
1833
"branch is opened.", (1, 8), None))
1834
self.create_hook(HookPoint('post_push',
1797
"branch is opened.", (1, 8))
1798
self.add_hook('post_push',
1835
1799
"Called after a push operation completes. post_push is called "
1836
1800
"with a bzrlib.branch.BranchPushResult object and only runs in the "
1837
"bzr client.", (0, 15), None))
1838
self.create_hook(HookPoint('post_pull',
1801
"bzr client.", (0, 15))
1802
self.add_hook('post_pull',
1839
1803
"Called after a pull operation completes. post_pull is called "
1840
1804
"with a bzrlib.branch.PullResult object and only runs in the "
1841
"bzr client.", (0, 15), None))
1842
self.create_hook(HookPoint('pre_commit',
1805
"bzr client.", (0, 15))
1806
self.add_hook('pre_commit',
1843
1807
"Called after a commit is calculated but before it is "
1844
1808
"completed. pre_commit is called with (local, master, old_revno, "
1845
1809
"old_revid, future_revno, future_revid, tree_delta, future_tree"
1848
1812
"basis revision. hooks MUST NOT modify this delta. "
1849
1813
" future_tree is an in-memory tree obtained from "
1850
1814
"CommitBuilder.revision_tree() and hooks MUST NOT modify this "
1851
"tree.", (0,91), None))
1852
self.create_hook(HookPoint('post_commit',
1816
self.add_hook('post_commit',
1853
1817
"Called in the bzr client after a commit has completed. "
1854
1818
"post_commit is called with (local, master, old_revno, old_revid, "
1855
1819
"new_revno, new_revid). old_revid is NULL_REVISION for the first "
1856
"commit to a branch.", (0, 15), None))
1857
self.create_hook(HookPoint('post_uncommit',
1820
"commit to a branch.", (0, 15))
1821
self.add_hook('post_uncommit',
1858
1822
"Called in the bzr client after an uncommit completes. "
1859
1823
"post_uncommit is called with (local, master, old_revno, "
1860
1824
"old_revid, new_revno, new_revid) where local is the local branch "
1861
1825
"or None, master is the target branch, and an empty branch "
1862
"receives new_revno of 0, new_revid of None.", (0, 15), None))
1863
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',
1864
1828
"Called in bzr client and server before a change to the tip of a "
1865
1829
"branch is made. pre_change_branch_tip is called with a "
1866
1830
"bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1867
"commit, uncommit will all trigger this hook.", (1, 6), None))
1868
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',
1869
1833
"Called in bzr client and server after a change to the tip of a "
1870
1834
"branch is made. post_change_branch_tip is called with a "
1871
1835
"bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1872
"commit, uncommit will all trigger this hook.", (1, 4), None))
1873
self.create_hook(HookPoint('transform_fallback_location',
1836
"commit, uncommit will all trigger this hook.", (1, 4))
1837
self.add_hook('transform_fallback_location',
1874
1838
"Called when a stacked branch is activating its fallback "
1875
1839
"locations. transform_fallback_location is called with (branch, "
1876
1840
"url), and should return a new url. Returning the same url "
1881
1845
"fallback locations have not been activated. When there are "
1882
1846
"multiple hooks installed for transform_fallback_location, "
1883
1847
"all are called with the url returned from the previous hook."
1884
"The order is however undefined.", (1, 9), None))
1885
self.create_hook(HookPoint('automatic_tag_name',
1848
"The order is however undefined.", (1, 9))
1849
self.add_hook('automatic_tag_name',
1886
1850
"Called to determine an automatic tag name for a revision. "
1887
1851
"automatic_tag_name is called with (branch, revision_id) and "
1888
1852
"should return a tag name or None if no tag name could be "
1889
1853
"determined. The first non-None tag name returned will be used.",
1891
self.create_hook(HookPoint('post_branch_init',
1855
self.add_hook('post_branch_init',
1892
1856
"Called after new branch initialization completes. "
1893
1857
"post_branch_init is called with a "
1894
1858
"bzrlib.branch.BranchInitHookParams. "
1895
1859
"Note that init, branch and checkout (both heavyweight and "
1896
"lightweight) will all trigger this hook.", (2, 2), None))
1897
self.create_hook(HookPoint('post_switch',
1860
"lightweight) will all trigger this hook.", (2, 2))
1861
self.add_hook('post_switch',
1898
1862
"Called after a checkout switches branch. "
1899
1863
"post_switch is called with a "
1900
"bzrlib.branch.SwitchHookParams.", (2, 2), None))
1864
"bzrlib.branch.SwitchHookParams.", (2, 2))
2016
1980
self.revision_id)
2019
class BzrBranchFormat4(BranchFormat):
2020
"""Bzr branch format 4.
2023
- a revision-history file.
2024
- a branch-lock lock file [ to be shared with the bzrdir ]
2027
def get_format_description(self):
2028
"""See BranchFormat.get_format_description()."""
2029
return "Branch format 4"
2031
def initialize(self, a_bzrdir, name=None, repository=None):
2032
"""Create a branch of this format in a_bzrdir."""
2033
if repository is not None:
2034
raise NotImplementedError(
2035
"initialize(repository=<not None>) on %r" % (self,))
2036
utf8_files = [('revision-history', ''),
2037
('branch-name', ''),
2039
return self._initialize_helper(a_bzrdir, utf8_files, name=name,
2040
lock_type='branch4', set_format=False)
2043
super(BzrBranchFormat4, self).__init__()
2044
self._matchingbzrdir = bzrdir.BzrDirFormat6()
2046
def network_name(self):
2047
"""The network name for this format is the control dirs disk label."""
2048
return self._matchingbzrdir.get_format_string()
2050
def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False,
2051
found_repository=None):
2052
"""See BranchFormat.open()."""
2054
# we are being called directly and must probe.
2055
raise NotImplementedError
2056
if found_repository is None:
2057
found_repository = a_bzrdir.open_repository()
2058
return BzrBranchPreSplitOut(_format=self,
2059
_control_files=a_bzrdir._control_files,
2062
_repository=found_repository)
2065
return "Bazaar-NG branch format 4"
2068
1983
class BranchFormatMetadir(BranchFormat):
2069
1984
"""Common logic for meta-dir based branch formats."""
2072
1987
"""What class to instantiate on open calls."""
2073
1988
raise NotImplementedError(self._branch_class)
1990
def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
1992
"""Initialize a branch in a bzrdir, with specified files
1994
:param a_bzrdir: The bzrdir to initialize the branch in
1995
:param utf8_files: The files to create as a list of
1996
(filename, content) tuples
1997
:param name: Name of colocated branch to create, if any
1998
:return: a branch in this format
2000
mutter('creating branch %r in %s', self, a_bzrdir.user_url)
2001
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
2002
control_files = lockable_files.LockableFiles(branch_transport,
2003
'lock', lockdir.LockDir)
2004
control_files.create_lock()
2005
control_files.lock_write()
2007
utf8_files += [('format', self.get_format_string())]
2008
for (filename, content) in utf8_files:
2009
branch_transport.put_bytes(
2011
mode=a_bzrdir._get_file_mode())
2013
control_files.unlock()
2014
branch = self.open(a_bzrdir, name, _found=True,
2015
found_repository=repository)
2016
self._run_post_branch_init_hooks(a_bzrdir, name, branch)
2075
2019
def network_name(self):
2076
2020
"""A simple byte string uniquely identifying this format for RPC calls.
2376
2341
__format6 = BzrBranchFormat6()
2377
2342
__format7 = BzrBranchFormat7()
2378
2343
__format8 = BzrBranchFormat8()
2379
BranchFormat.register_format(__format5)
2380
BranchFormat.register_format(BranchReferenceFormat())
2381
BranchFormat.register_format(__format6)
2382
BranchFormat.register_format(__format7)
2383
BranchFormat.register_format(__format8)
2384
BranchFormat.set_default_format(__format7)
2385
_legacy_formats = [BzrBranchFormat4(),
2387
network_format_registry.register(
2388
_legacy_formats[0].network_name(), _legacy_formats[0].__class__)
2344
format_registry.register(__format5)
2345
format_registry.register(BranchReferenceFormat())
2346
format_registry.register(__format6)
2347
format_registry.register(__format7)
2348
format_registry.register(__format8)
2349
format_registry.set_default(__format7)
2391
2352
class BranchWriteLockResult(LogicalLockResult):
2539
2500
"""See Branch.print_file."""
2540
2501
return self.repository.print_file(file, revision_id)
2542
def _write_revision_history(self, history):
2543
"""Factored out of set_revision_history.
2545
This performs the actual writing to disk.
2546
It is intended to be called by BzrBranch5.set_revision_history."""
2547
self._transport.put_bytes(
2548
'revision-history', '\n'.join(history),
2549
mode=self.bzrdir._get_file_mode())
2552
def set_revision_history(self, rev_history):
2553
"""See Branch.set_revision_history."""
2554
if 'evil' in debug.debug_flags:
2555
mutter_callsite(3, "set_revision_history scales with history.")
2556
check_not_reserved_id = _mod_revision.check_not_reserved_id
2557
for rev_id in rev_history:
2558
check_not_reserved_id(rev_id)
2559
if Branch.hooks['post_change_branch_tip']:
2560
# Don't calculate the last_revision_info() if there are no hooks
2562
old_revno, old_revid = self.last_revision_info()
2563
if len(rev_history) == 0:
2564
revid = _mod_revision.NULL_REVISION
2566
revid = rev_history[-1]
2567
self._run_pre_change_branch_tip_hooks(len(rev_history), revid)
2568
self._write_revision_history(rev_history)
2569
self._clear_cached_state()
2570
self._cache_revision_history(rev_history)
2571
for hook in Branch.hooks['set_rh']:
2572
hook(self, rev_history)
2573
if Branch.hooks['post_change_branch_tip']:
2574
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2576
def _synchronize_history(self, destination, revision_id):
2577
"""Synchronize last revision and revision history between branches.
2579
This version is most efficient when the destination is also a
2580
BzrBranch5, but works for BzrBranch6 as long as the revision
2581
history is the true lefthand parent history, and all of the revisions
2582
are in the destination's repository. If not, set_revision_history
2585
:param destination: The branch to copy the history into
2586
:param revision_id: The revision-id to truncate history at. May
2587
be None to copy complete history.
2589
if not isinstance(destination._format, BzrBranchFormat5):
2590
super(BzrBranch, self)._synchronize_history(
2591
destination, revision_id)
2593
if revision_id == _mod_revision.NULL_REVISION:
2596
new_history = self.revision_history()
2597
if revision_id is not None and new_history != []:
2599
new_history = new_history[:new_history.index(revision_id) + 1]
2601
rev = self.repository.get_revision(revision_id)
2602
new_history = rev.get_history(self.repository)[1:]
2603
destination.set_revision_history(new_history)
2605
2503
@needs_write_lock
2606
2504
def set_last_revision_info(self, revno, revision_id):
2607
"""Set the last revision of this branch.
2609
The caller is responsible for checking that the revno is correct
2610
for this revision id.
2612
It may be possible to set the branch last revision to an id not
2613
present in the repository. However, branches can also be
2614
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)
2617
2507
revision_id = _mod_revision.ensure_null(revision_id)
2618
# this old format stores the full history, but this api doesn't
2619
# provide it, so we must generate, and might as well check it's
2621
history = self._lefthand_history(revision_id)
2622
if len(history) != revno:
2623
raise AssertionError('%d != %d' % (len(history), revno))
2624
self.set_revision_history(history)
2626
def _gen_revision_history(self):
2627
history = self._transport.get_bytes('revision-history').split('\n')
2628
if history[-1:] == ['']:
2629
# There shouldn't be a trailing newline, but just in case.
2634
def generate_revision_history(self, revision_id, last_rev=None,
2636
"""Create a new revision history that will finish with revision_id.
2638
:param revision_id: the new tip to use.
2639
:param last_rev: The previous last_revision. If not None, then this
2640
must be a ancestory of revision_id, or DivergedBranches is raised.
2641
:param other_branch: The other branch that DivergedBranches should
2642
raise with respect to.
2644
self.set_revision_history(self._lefthand_history(revision_id,
2645
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)
2647
2517
def basis_tree(self):
2648
2518
"""See Branch.basis_tree."""
2660
def _basic_push(self, target, overwrite, stop_revision):
2661
"""Basic implementation of push without bound branches or hooks.
2663
Must be called with source read locked and target write locked.
2665
result = BranchPushResult()
2666
result.source_branch = self
2667
result.target_branch = target
2668
result.old_revno, result.old_revid = target.last_revision_info()
2669
self.update_references(target)
2670
if result.old_revid != self.last_revision():
2671
# We assume that during 'push' this repository is closer than
2673
graph = self.repository.get_graph(target.repository)
2674
target.update_revisions(self, stop_revision,
2675
overwrite=overwrite, graph=graph)
2676
if self._push_should_merge_tags():
2677
result.tag_conflicts = self.tags.merge_to(target.tags, overwrite)
2678
result.new_revno, result.new_revid = target.last_revision_info()
2681
2530
def get_stacked_on_url(self):
2682
2531
raise errors.UnstackableBranchFormat(self._format, self.user_url)
2694
2543
self._transport.put_bytes('parent', url + '\n',
2695
2544
mode=self.bzrdir._get_file_mode())
2698
class BzrBranchPreSplitOut(BzrBranch):
2700
def _get_checkout_format(self):
2701
"""Return the most suitable metadir for a checkout of this branch.
2702
Weaves are used if this branch's repository uses weaves.
2548
"""If bound, unbind"""
2549
return self.set_bound_location(None)
2552
def bind(self, other):
2553
"""Bind this branch to the branch other.
2555
This does not push or pull data between the branches, though it does
2556
check for divergence to raise an error when the branches are not
2557
either the same, or one a prefix of the other. That behaviour may not
2558
be useful, so that check may be removed in future.
2560
:param other: The branch to bind to
2704
from bzrlib.repofmt.weaverepo import RepositoryFormat7
2705
from bzrlib.bzrdir import BzrDirMetaFormat1
2706
format = BzrDirMetaFormat1()
2707
format.repository_format = RepositoryFormat7()
2711
class BzrBranch5(BzrBranch):
2712
"""A format 5 branch. This supports new features over plain branches.
2714
It has support for a master_branch which is the data for bound branches.
2563
# TODO: jam 20051230 Consider checking if the target is bound
2564
# It is debatable whether you should be able to bind to
2565
# a branch which is itself bound.
2566
# Committing is obviously forbidden,
2567
# but binding itself may not be.
2568
# Since we *have* to check at commit time, we don't
2569
# *need* to check here
2571
# we want to raise diverged if:
2572
# last_rev is not in the other_last_rev history, AND
2573
# other_last_rev is not in our history, and do it without pulling
2575
self.set_bound_location(other.base)
2717
2577
def get_bound_location(self):
2762
2622
@needs_write_lock
2763
def bind(self, other):
2764
"""Bind this branch to the branch other.
2766
This does not push or pull data between the branches, though it does
2767
check for divergence to raise an error when the branches are not
2768
either the same, or one a prefix of the other. That behaviour may not
2769
be useful, so that check may be removed in future.
2771
:param other: The branch to bind to
2774
# TODO: jam 20051230 Consider checking if the target is bound
2775
# It is debatable whether you should be able to bind to
2776
# a branch which is itself bound.
2777
# Committing is obviously forbidden,
2778
# but binding itself may not be.
2779
# Since we *have* to check at commit time, we don't
2780
# *need* to check here
2782
# we want to raise diverged if:
2783
# last_rev is not in the other_last_rev history, AND
2784
# other_last_rev is not in our history, and do it without pulling
2786
self.set_bound_location(other.base)
2790
"""If bound, unbind"""
2791
return self.set_bound_location(None)
2794
2623
def update(self, possible_transports=None):
2795
2624
"""Synchronise this branch with the master branch if any.
2811
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):
2812
2768
"""A branch that stores tree-reference locations."""
2814
2770
def _open_hook(self):
2840
2796
self._last_revision_info_cache = None
2841
2797
self._reference_info = None
2843
def _last_revision_info(self):
2844
revision_string = self._transport.get_bytes('last-revision')
2845
revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
2846
revision_id = cache_utf8.get_cached_utf8(revision_id)
2848
return revno, revision_id
2850
def _write_last_revision_info(self, revno, revision_id):
2851
"""Simply write out the revision id, with no checks.
2853
Use set_last_revision_info to perform this safely.
2855
Does not update the revision_history cache.
2856
Intended to be called by set_last_revision_info and
2857
_write_revision_history.
2859
revision_id = _mod_revision.ensure_null(revision_id)
2860
out_string = '%d %s\n' % (revno, revision_id)
2861
self._transport.put_bytes('last-revision', out_string,
2862
mode=self.bzrdir._get_file_mode())
2865
def set_last_revision_info(self, revno, revision_id):
2866
revision_id = _mod_revision.ensure_null(revision_id)
2867
old_revno, old_revid = self.last_revision_info()
2868
if self._get_append_revisions_only():
2869
self._check_history_violation(revision_id)
2870
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2871
self._write_last_revision_info(revno, revision_id)
2872
self._clear_cached_state()
2873
self._last_revision_info_cache = revno, revision_id
2874
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2876
def _synchronize_history(self, destination, revision_id):
2877
"""Synchronize last revision and revision history between branches.
2879
:see: Branch._synchronize_history
2881
# XXX: The base Branch has a fast implementation of this method based
2882
# on set_last_revision_info, but BzrBranch/BzrBranch5 have a slower one
2883
# that uses set_revision_history. This class inherits from BzrBranch5,
2884
# but wants the fast implementation, so it calls
2885
# Branch._synchronize_history directly.
2886
Branch._synchronize_history(self, destination, revision_id)
2888
2799
def _check_history_violation(self, revision_id):
2889
last_revision = _mod_revision.ensure_null(self.last_revision())
2800
current_revid = self.last_revision()
2801
last_revision = _mod_revision.ensure_null(current_revid)
2890
2802
if _mod_revision.is_null(last_revision):
2892
if last_revision not in self._lefthand_history(revision_id):
2893
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)
2895
2810
def _gen_revision_history(self):
2896
2811
"""Generate the revision history from last revision
3276
3174
branch._transport.put_bytes('format', format.get_format_string())
3279
def _run_with_write_locked_target(target, callable, *args, **kwargs):
3280
"""Run ``callable(*args, **kwargs)``, write-locking target for the
3283
_run_with_write_locked_target will attempt to release the lock it acquires.
3285
If an exception is raised by callable, then that exception *will* be
3286
propagated, even if the unlock attempt raises its own error. Thus
3287
_run_with_write_locked_target should be preferred to simply doing::
3291
return callable(*args, **kwargs)
3296
# This is very similar to bzrlib.decorators.needs_write_lock. Perhaps they
3297
# should share code?
3300
result = callable(*args, **kwargs)
3302
exc_info = sys.exc_info()
3306
raise exc_info[0], exc_info[1], exc_info[2]
3312
3177
class InterBranch(InterObject):
3313
3178
"""This class represents operations taking place between two branches.
3342
3207
raise NotImplementedError(self.pull)
3344
3209
@needs_write_lock
3345
def update_revisions(self, stop_revision=None, overwrite=False,
3347
"""Pull in new perfect-fit revisions.
3349
:param stop_revision: Updated until the given revision
3350
:param overwrite: Always set the branch pointer, rather than checking
3351
to see if it is a proper descendant.
3352
:param graph: A Graph object that can be used to query history
3353
information. This can be None.
3356
raise NotImplementedError(self.update_revisions)
3359
def push(self, overwrite=False, stop_revision=None,
3210
def push(self, overwrite=False, stop_revision=None, lossy=False,
3360
3211
_override_hook_source_branch=None):
3361
3212
"""Mirror the source branch into the target branch.
3413
3273
self.source.tags.merge_to(self.target.tags)
3415
3275
@needs_write_lock
3416
def update_revisions(self, stop_revision=None, overwrite=False,
3418
"""See InterBranch.update_revisions()."""
3276
def fetch(self, stop_revision=None, limit=None):
3277
if self.target.base == self.source.base:
3279
self.source.lock_read()
3281
fetch_spec_factory = fetch.FetchSpecFactory()
3282
fetch_spec_factory.source_branch = self.source
3283
fetch_spec_factory.source_branch_stop_revision_id = stop_revision
3284
fetch_spec_factory.source_repo = self.source.repository
3285
fetch_spec_factory.target_repo = self.target.repository
3286
fetch_spec_factory.target_repo_kind = fetch.TargetRepoKinds.PREEXISTING
3287
fetch_spec_factory.limit = limit
3288
fetch_spec = fetch_spec_factory.make_fetch_spec()
3289
return self.target.repository.fetch(self.source.repository,
3290
fetch_spec=fetch_spec)
3292
self.source.unlock()
3295
def _update_revisions(self, stop_revision=None, overwrite=False,
3419
3297
other_revno, other_last_revision = self.source.last_revision_info()
3420
3298
stop_revno = None # unknown
3421
3299
if stop_revision is None:
3485
3363
if master_branch:
3486
3364
master_branch.unlock()
3488
def push(self, overwrite=False, stop_revision=None,
3366
def push(self, overwrite=False, stop_revision=None, lossy=False,
3489
3367
_override_hook_source_branch=None):
3490
3368
"""See InterBranch.push.
3492
3370
This is the basic concrete implementation of push()
3494
:param _override_hook_source_branch: If specified, run
3495
the hooks passing this Branch as the source, rather than self.
3496
This is for use of RemoteBranch, where push is delegated to the
3497
underlying vfs-based Branch.
3372
:param _override_hook_source_branch: If specified, run the hooks
3373
passing this Branch as the source, rather than self. This is for
3374
use of RemoteBranch, where push is delegated to the underlying
3378
raise errors.LossyPushToSameVCS(self.source, self.target)
3499
3379
# TODO: Public option to disable running hooks - should be trivial but
3501
self.source.lock_read()
3503
return _run_with_write_locked_target(
3504
self.target, self._push_with_bound_branches, overwrite,
3506
_override_hook_source_branch=_override_hook_source_branch)
3508
self.source.unlock()
3510
def _push_with_bound_branches(self, overwrite, stop_revision,
3382
op = cleanup.OperationWithCleanups(self._push_with_bound_branches)
3383
op.add_cleanup(self.source.lock_read().unlock)
3384
op.add_cleanup(self.target.lock_write().unlock)
3385
return op.run(overwrite, stop_revision,
3386
_override_hook_source_branch=_override_hook_source_branch)
3388
def _basic_push(self, overwrite, stop_revision):
3389
"""Basic implementation of push without bound branches or hooks.
3391
Must be called with source read locked and target write locked.
3393
result = BranchPushResult()
3394
result.source_branch = self.source
3395
result.target_branch = self.target
3396
result.old_revno, result.old_revid = self.target.last_revision_info()
3397
self.source.update_references(self.target)
3398
if result.old_revid != stop_revision:
3399
# We assume that during 'push' this repository is closer than
3401
graph = self.source.repository.get_graph(self.target.repository)
3402
self._update_revisions(stop_revision, overwrite=overwrite,
3404
if self.source._push_should_merge_tags():
3405
result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
3407
result.new_revno, result.new_revid = self.target.last_revision_info()
3410
def _push_with_bound_branches(self, operation, overwrite, stop_revision,
3511
3411
_override_hook_source_branch=None):
3512
3412
"""Push from source into target, and into target's master if any.
3525
3425
# be bound to itself? -- mbp 20070507
3526
3426
master_branch = self.target.get_master_branch()
3527
3427
master_branch.lock_write()
3529
# push into the master from the source branch.
3530
self.source._basic_push(master_branch, overwrite, stop_revision)
3531
# and push into the target branch from the source. Note that we
3532
# push from the source branch again, because it's considered the
3533
# highest bandwidth repository.
3534
result = self.source._basic_push(self.target, overwrite,
3536
result.master_branch = master_branch
3537
result.local_branch = self.target
3541
master_branch.unlock()
3428
operation.add_cleanup(master_branch.unlock)
3429
# push into the master from the source branch.
3430
master_inter = InterBranch.get(self.source, master_branch)
3431
master_inter._basic_push(overwrite, stop_revision)
3432
# and push into the target branch from the source. Note that
3433
# we push from the source branch again, because it's considered
3434
# the highest bandwidth repository.
3435
result = self._basic_push(overwrite, stop_revision)
3436
result.master_branch = master_branch
3437
result.local_branch = self.target
3439
master_branch = None
3543
3440
# no master branch
3544
result = self.source._basic_push(self.target, overwrite,
3441
result = self._basic_push(overwrite, stop_revision)
3546
3442
# TODO: Why set master_branch and local_branch if there's no
3547
3443
# binding? Maybe cleaner to just leave them unset? -- mbp
3549
3445
result.master_branch = self.target
3550
3446
result.local_branch = None
3554
3450
def _pull(self, overwrite=False, stop_revision=None,
3555
3451
possible_transports=None, _hook_master=None, run_hooks=True,
added
removed
bzrlib/branch.py
