648
669
raise errors.UnsupportedOperation(self.get_reference_info, self)
650
671
@needs_write_lock
651
def fetch(self, from_branch, last_revision=None, pb=None):
672
def fetch(self, from_branch, last_revision=None):
652
673
"""Copy revisions from from_branch into this branch.
654
675
:param from_branch: Where to copy from.
655
676
:param last_revision: What revision to stop at (None for at the end
657
:param pb: An optional progress bar to use.
660
if self.base == from_branch.base:
663
symbol_versioning.warn(
664
symbol_versioning.deprecated_in((1, 14, 0))
665
% "pb parameter to fetch()")
666
from_branch.lock_read()
668
if last_revision is None:
669
last_revision = from_branch.last_revision()
670
last_revision = _mod_revision.ensure_null(last_revision)
671
return self.repository.fetch(from_branch.repository,
672
revision_id=last_revision,
680
return InterBranch.get(from_branch, self).fetch(last_revision)
677
682
def get_bound_location(self):
678
683
"""Return the URL of the branch we are bound to.
738
746
"""Print `file` to stdout."""
739
747
raise NotImplementedError(self.print_file)
749
@deprecated_method(deprecated_in((2, 4, 0)))
741
750
def set_revision_history(self, rev_history):
742
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)
744
791
@needs_write_lock
745
792
def set_parent(self, url):
858
906
# XXX: If you unstack a branch while it has a working tree
859
907
# with a pending merge, the pending-merged revisions will no
860
908
# longer be present. You can (probably) revert and remerge.
862
# XXX: This only fetches up to the tip of the repository; it
863
# doesn't bring across any tags. That's fairly consistent
864
# with how branch works, but perhaps not ideal.
865
self.repository.fetch(old_repository,
866
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)
869
918
old_repository.unlock()
967
1022
:return: A tuple (revno, revision_id).
969
1024
if self._last_revision_info_cache is None:
970
self._last_revision_info_cache = self._last_revision_info()
1025
self._last_revision_info_cache = self._read_last_revision_info()
971
1026
return self._last_revision_info_cache
973
def _last_revision_info(self):
974
rh = self.revision_history()
977
return (revno, rh[-1])
979
return (0, _mod_revision.NULL_REVISION)
981
@deprecated_method(deprecated_in((1, 6, 0)))
982
def missing_revisions(self, other, stop_revision=None):
983
"""Return a list of new revisions that would perfectly fit.
985
If self and other have not diverged, return a list of the revisions
986
present in other, but missing from self.
988
self_history = self.revision_history()
989
self_len = len(self_history)
990
other_history = other.revision_history()
991
other_len = len(other_history)
992
common_index = min(self_len, other_len) -1
993
if common_index >= 0 and \
994
self_history[common_index] != other_history[common_index]:
995
raise errors.DivergedBranches(self, other)
997
if stop_revision is None:
998
stop_revision = other_len
1000
if stop_revision > other_len:
1001
raise errors.NoSuchRevision(self, stop_revision)
1002
return other_history[self_len:stop_revision]
1004
def update_revisions(self, other, stop_revision=None, overwrite=False,
1006
"""Pull in new perfect-fit revisions.
1008
:param other: Another Branch to pull from
1009
:param stop_revision: Updated until the given revision
1010
:param overwrite: Always set the branch pointer, rather than checking
1011
to see if it is a proper descendant.
1012
:param graph: A Graph object that can be used to query history
1013
information. This can be None.
1016
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)))
1019
1032
def import_last_revision_info(self, source_repo, revno, revid):
1020
1033
"""Set the last revision info, importing from another repo if necessary.
1022
This is used by the bound branch code to upload a revision to
1023
the master branch first before updating the tip of the local branch.
1025
1035
:param source_repo: Source repository to optionally fetch from
1026
1036
:param revno: Revision number of the new tip
1027
1037
:param revid: Revision id of the new tip
1030
1040
self.repository.fetch(source_repo, revision_id=revid)
1031
1041
self.set_last_revision_info(revno, revid)
1043
def import_last_revision_info_and_tags(self, source, revno, revid,
1045
"""Set the last revision info, importing from another repo if necessary.
1047
This is used by the bound branch code to upload a revision to
1048
the master branch first before updating the tip of the local branch.
1049
Revisions referenced by source's tags are also transferred.
1051
:param source: Source branch to optionally fetch from
1052
:param revno: Revision number of the new tip
1053
:param revid: Revision id of the new tip
1054
:param lossy: Whether to discard metadata that can not be
1055
natively represented
1056
:return: Tuple with the new revision number and revision id
1057
(should only be different from the arguments when lossy=True)
1059
if not self.repository.has_same_location(source.repository):
1060
self.fetch(source, revid)
1061
self.set_last_revision_info(revno, revid)
1062
return (revno, revid)
1033
1064
def revision_id_to_revno(self, revision_id):
1034
1065
"""Given a revision id, return its revno"""
1035
1066
if _mod_revision.is_null(revision_id):
1361
1397
"""Return the most suitable metadir for a checkout of this branch.
1362
1398
Weaves are used if this branch's repository uses weaves.
1364
if isinstance(self.bzrdir, bzrdir.BzrDirPreSplitOut):
1365
from bzrlib.repofmt import weaverepo
1366
format = bzrdir.BzrDirMetaFormat1()
1367
format.repository_format = weaverepo.RepositoryFormat7()
1369
format = self.repository.bzrdir.checkout_metadir()
1370
format.set_branch_format(self._format)
1400
format = self.repository.bzrdir.checkout_metadir()
1401
format.set_branch_format(self._format)
1373
1404
def create_clone_on_transport(self, to_transport, revision_id=None,
1374
stacked_on=None, create_prefix=False, use_existing_dir=False):
1405
stacked_on=None, create_prefix=False, use_existing_dir=False,
1375
1407
"""Create a clone of this branch and its bzrdir.
1377
1409
:param to_transport: The transport to clone onto.
1512
1545
raise AssertionError("invalid heads: %r" % (heads,))
1515
class BranchFormat(object):
1547
def heads_to_fetch(self):
1548
"""Return the heads that must and that should be fetched to copy this
1549
branch into another repo.
1551
:returns: a 2-tuple of (must_fetch, if_present_fetch). must_fetch is a
1552
set of heads that must be fetched. if_present_fetch is a set of
1553
heads that must be fetched if present, but no error is necessary if
1554
they are not present.
1556
# For bzr native formats must_fetch is just the tip, and if_present_fetch
1558
must_fetch = set([self.last_revision()])
1560
if_present_fetch = set(self.tags.get_reverse_tag_dict())
1561
except errors.TagsNotSupported:
1562
if_present_fetch = set()
1563
must_fetch.discard(_mod_revision.NULL_REVISION)
1564
if_present_fetch.discard(_mod_revision.NULL_REVISION)
1565
return must_fetch, if_present_fetch
1568
class BranchFormat(controldir.ControlComponentFormat):
1516
1569
"""An encapsulation of the initialization and open routines for a format.
1518
1571
Formats provide three things:
1551
1598
transport = a_bzrdir.get_branch_transport(None, name=name)
1552
1599
format_string = transport.get_bytes("format")
1553
format = klass._formats[format_string]
1554
if isinstance(format, MetaDirBranchFormatFactory):
1600
return format_registry.get(format_string)
1557
1601
except errors.NoSuchFile:
1558
1602
raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1559
1603
except KeyError:
1560
1604
raise errors.UnknownFormatError(format=format_string, kind='branch')
1607
@deprecated_method(deprecated_in((2, 4, 0)))
1563
1608
def get_default_format(klass):
1564
1609
"""Return the current default format."""
1565
return klass._default_format
1610
return format_registry.get_default()
1613
@deprecated_method(deprecated_in((2, 4, 0)))
1568
1614
def get_formats(klass):
1569
1615
"""Get all the known formats.
1571
1617
Warning: This triggers a load of all lazy registered formats: do not
1572
1618
use except when that is desireed.
1575
for fmt in klass._formats.values():
1576
if isinstance(fmt, MetaDirBranchFormatFactory):
1620
return format_registry._get_all()
1581
1622
def get_reference(self, a_bzrdir, name=None):
1582
1623
"""Get the target reference of the branch in a_bzrdir.
1621
1662
for hook in hooks:
1624
def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
1625
lock_type='metadir', set_format=True):
1626
"""Initialize a branch in a bzrdir, with specified files
1628
:param a_bzrdir: The bzrdir to initialize the branch in
1629
:param utf8_files: The files to create as a list of
1630
(filename, content) tuples
1631
:param name: Name of colocated branch to create, if any
1632
:param set_format: If True, set the format with
1633
self.get_format_string. (BzrBranch4 has its format set
1635
:return: a branch in this format
1637
mutter('creating branch %r in %s', self, a_bzrdir.user_url)
1638
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1640
'metadir': ('lock', lockdir.LockDir),
1641
'branch4': ('branch-lock', lockable_files.TransportLock),
1643
lock_name, lock_class = lock_map[lock_type]
1644
control_files = lockable_files.LockableFiles(branch_transport,
1645
lock_name, lock_class)
1646
control_files.create_lock()
1648
control_files.lock_write()
1649
except errors.LockContention:
1650
if lock_type != 'branch4':
1656
utf8_files += [('format', self.get_format_string())]
1658
for (filename, content) in utf8_files:
1659
branch_transport.put_bytes(
1661
mode=a_bzrdir._get_file_mode())
1664
control_files.unlock()
1665
branch = self.open(a_bzrdir, name, _found=True)
1666
self._run_post_branch_init_hooks(a_bzrdir, name, branch)
1669
def initialize(self, a_bzrdir, name=None):
1665
def initialize(self, a_bzrdir, name=None, repository=None):
1670
1666
"""Create a branch of this format in a_bzrdir.
1672
1668
:param name: Name of the colocated branch to create.
1719
1716
raise NotImplementedError(self.open)
1719
@deprecated_method(deprecated_in((2, 4, 0)))
1722
1720
def register_format(klass, format):
1723
1721
"""Register a metadir format.
1725
1723
See MetaDirBranchFormatFactory for the ability to register a format
1726
1724
without loading the code the format needs until it is actually used.
1728
klass._formats[format.get_format_string()] = format
1729
# Metadir formats have a network name of their format string, and get
1730
# registered as factories.
1731
if isinstance(format, MetaDirBranchFormatFactory):
1732
network_format_registry.register(format.get_format_string(), format)
1734
network_format_registry.register(format.get_format_string(),
1726
format_registry.register(format)
1729
@deprecated_method(deprecated_in((2, 4, 0)))
1738
1730
def set_default_format(klass, format):
1739
klass._default_format = format
1731
format_registry.set_default(format)
1741
1733
def supports_set_append_revisions_only(self):
1742
1734
"""True if this format supports set_append_revisions_only."""
1799
1796
These are all empty initially, because by default nothing should get
1802
Hooks.__init__(self)
1803
self.create_hook(HookPoint('set_rh',
1799
Hooks.__init__(self, "bzrlib.branch", "Branch.hooks")
1800
self.add_hook('set_rh',
1804
1801
"Invoked whenever the revision history has been set via "
1805
1802
"set_revision_history. The api signature is (branch, "
1806
1803
"revision_history), and the branch will be write-locked. "
1807
1804
"The set_rh hook can be expensive for bzr to trigger, a better "
1808
"hook to use is Branch.post_change_branch_tip.", (0, 15), None))
1809
self.create_hook(HookPoint('open',
1805
"hook to use is Branch.post_change_branch_tip.", (0, 15))
1806
self.add_hook('open',
1810
1807
"Called with the Branch object that has been opened after a "
1811
"branch is opened.", (1, 8), None))
1812
self.create_hook(HookPoint('post_push',
1808
"branch is opened.", (1, 8))
1809
self.add_hook('post_push',
1813
1810
"Called after a push operation completes. post_push is called "
1814
1811
"with a bzrlib.branch.BranchPushResult object and only runs in the "
1815
"bzr client.", (0, 15), None))
1816
self.create_hook(HookPoint('post_pull',
1812
"bzr client.", (0, 15))
1813
self.add_hook('post_pull',
1817
1814
"Called after a pull operation completes. post_pull is called "
1818
1815
"with a bzrlib.branch.PullResult object and only runs in the "
1819
"bzr client.", (0, 15), None))
1820
self.create_hook(HookPoint('pre_commit',
1821
"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 "
1822
1819
"completed. pre_commit is called with (local, master, old_revno, "
1823
1820
"old_revid, future_revno, future_revid, tree_delta, future_tree"
1824
1821
"). old_revid is NULL_REVISION for the first commit to a branch, "
1826
1823
"basis revision. hooks MUST NOT modify this delta. "
1827
1824
" future_tree is an in-memory tree obtained from "
1828
1825
"CommitBuilder.revision_tree() and hooks MUST NOT modify this "
1829
"tree.", (0,91), None))
1830
self.create_hook(HookPoint('post_commit',
1827
self.add_hook('post_commit',
1831
1828
"Called in the bzr client after a commit has completed. "
1832
1829
"post_commit is called with (local, master, old_revno, old_revid, "
1833
1830
"new_revno, new_revid). old_revid is NULL_REVISION for the first "
1834
"commit to a branch.", (0, 15), None))
1835
self.create_hook(HookPoint('post_uncommit',
1831
"commit to a branch.", (0, 15))
1832
self.add_hook('post_uncommit',
1836
1833
"Called in the bzr client after an uncommit completes. "
1837
1834
"post_uncommit is called with (local, master, old_revno, "
1838
1835
"old_revid, new_revno, new_revid) where local is the local branch "
1839
1836
"or None, master is the target branch, and an empty branch "
1840
"receives new_revno of 0, new_revid of None.", (0, 15), None))
1841
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',
1842
1839
"Called in bzr client and server before a change to the tip of a "
1843
1840
"branch is made. pre_change_branch_tip is called with a "
1844
1841
"bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1845
"commit, uncommit will all trigger this hook.", (1, 6), None))
1846
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',
1847
1844
"Called in bzr client and server after a change to the tip of a "
1848
1845
"branch is made. post_change_branch_tip is called with a "
1849
1846
"bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1850
"commit, uncommit will all trigger this hook.", (1, 4), None))
1851
self.create_hook(HookPoint('transform_fallback_location',
1847
"commit, uncommit will all trigger this hook.", (1, 4))
1848
self.add_hook('transform_fallback_location',
1852
1849
"Called when a stacked branch is activating its fallback "
1853
1850
"locations. transform_fallback_location is called with (branch, "
1854
1851
"url), and should return a new url. Returning the same url "
1859
1856
"fallback locations have not been activated. When there are "
1860
1857
"multiple hooks installed for transform_fallback_location, "
1861
1858
"all are called with the url returned from the previous hook."
1862
"The order is however undefined.", (1, 9), None))
1863
self.create_hook(HookPoint('automatic_tag_name',
1864
"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. "
1865
1862
"automatic_tag_name is called with (branch, revision_id) and "
1866
1863
"should return a tag name or None if no tag name could be "
1867
1864
"determined. The first non-None tag name returned will be used.",
1869
self.create_hook(HookPoint('post_branch_init',
1866
self.add_hook('post_branch_init',
1870
1867
"Called after new branch initialization completes. "
1871
1868
"post_branch_init is called with a "
1872
1869
"bzrlib.branch.BranchInitHookParams. "
1873
1870
"Note that init, branch and checkout (both heavyweight and "
1874
"lightweight) will all trigger this hook.", (2, 2), None))
1875
self.create_hook(HookPoint('post_switch',
1871
"lightweight) will all trigger this hook.", (2, 2))
1872
self.add_hook('post_switch',
1876
1873
"Called after a checkout switches branch. "
1877
1874
"post_switch is called with a "
1878
"bzrlib.branch.SwitchHookParams.", (2, 2), None))
1875
"bzrlib.branch.SwitchHookParams.", (2, 2))
1999
1991
self.revision_id)
2002
class BzrBranchFormat4(BranchFormat):
2003
"""Bzr branch format 4.
2006
- a revision-history file.
2007
- a branch-lock lock file [ to be shared with the bzrdir ]
2010
def get_format_description(self):
2011
"""See BranchFormat.get_format_description()."""
2012
return "Branch format 4"
2014
def initialize(self, a_bzrdir, name=None):
2015
"""Create a branch of this format in a_bzrdir."""
2016
utf8_files = [('revision-history', ''),
2017
('branch-name', ''),
2019
return self._initialize_helper(a_bzrdir, utf8_files, name=name,
2020
lock_type='branch4', set_format=False)
2023
super(BzrBranchFormat4, self).__init__()
2024
self._matchingbzrdir = bzrdir.BzrDirFormat6()
2026
def network_name(self):
2027
"""The network name for this format is the control dirs disk label."""
2028
return self._matchingbzrdir.get_format_string()
2030
def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
2031
"""See BranchFormat.open()."""
2033
# we are being called directly and must probe.
2034
raise NotImplementedError
2035
return BzrBranch(_format=self,
2036
_control_files=a_bzrdir._control_files,
2039
_repository=a_bzrdir.open_repository())
2042
return "Bazaar-NG branch format 4"
2045
1994
class BranchFormatMetadir(BranchFormat):
2046
1995
"""Common logic for meta-dir based branch formats."""
2049
1998
"""What class to instantiate on open calls."""
2050
1999
raise NotImplementedError(self._branch_class)
2001
def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
2003
"""Initialize a branch in a bzrdir, with specified files
2005
:param a_bzrdir: The bzrdir to initialize the branch in
2006
:param utf8_files: The files to create as a list of
2007
(filename, content) tuples
2008
:param name: Name of colocated branch to create, if any
2009
:return: a branch in this format
2011
mutter('creating branch %r in %s', self, a_bzrdir.user_url)
2012
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
2013
control_files = lockable_files.LockableFiles(branch_transport,
2014
'lock', lockdir.LockDir)
2015
control_files.create_lock()
2016
control_files.lock_write()
2018
utf8_files += [('format', self.get_format_string())]
2019
for (filename, content) in utf8_files:
2020
branch_transport.put_bytes(
2022
mode=a_bzrdir._get_file_mode())
2024
control_files.unlock()
2025
branch = self.open(a_bzrdir, name, _found=True,
2026
found_repository=repository)
2027
self._run_post_branch_init_hooks(a_bzrdir, name, branch)
2052
2030
def network_name(self):
2053
2031
"""A simple byte string uniquely identifying this format for RPC calls.
2172
2156
"""See BranchFormat.get_format_description()."""
2173
2157
return "Branch format 8"
2175
def initialize(self, a_bzrdir, name=None):
2159
def initialize(self, a_bzrdir, name=None, repository=None):
2176
2160
"""Create a branch of this format in a_bzrdir."""
2177
2161
utf8_files = [('last-revision', '0 null:\n'),
2178
2162
('branch.conf', ''),
2180
2164
('references', '')
2182
return self._initialize_helper(a_bzrdir, utf8_files, name)
2185
super(BzrBranchFormat8, self).__init__()
2186
self._matchingbzrdir.repository_format = \
2187
RepositoryFormatKnitPack5RichRoot()
2166
return self._initialize_helper(a_bzrdir, utf8_files, name, repository)
2189
2168
def make_tags(self, branch):
2190
2169
"""See bzrlib.branch.BranchFormat.make_tags()."""
2348
2352
__format6 = BzrBranchFormat6()
2349
2353
__format7 = BzrBranchFormat7()
2350
2354
__format8 = BzrBranchFormat8()
2351
BranchFormat.register_format(__format5)
2352
BranchFormat.register_format(BranchReferenceFormat())
2353
BranchFormat.register_format(__format6)
2354
BranchFormat.register_format(__format7)
2355
BranchFormat.register_format(__format8)
2356
BranchFormat.set_default_format(__format7)
2357
_legacy_formats = [BzrBranchFormat4(),
2359
network_format_registry.register(
2360
_legacy_formats[0].network_name(), _legacy_formats[0].__class__)
2355
format_registry.register(__format5)
2356
format_registry.register(BranchReferenceFormat())
2357
format_registry.register(__format6)
2358
format_registry.register(__format7)
2359
format_registry.register(__format8)
2360
format_registry.set_default(__format7)
2363
2363
class BranchWriteLockResult(LogicalLockResult):
2511
2511
"""See Branch.print_file."""
2512
2512
return self.repository.print_file(file, revision_id)
2514
def _write_revision_history(self, history):
2515
"""Factored out of set_revision_history.
2517
This performs the actual writing to disk.
2518
It is intended to be called by BzrBranch5.set_revision_history."""
2519
self._transport.put_bytes(
2520
'revision-history', '\n'.join(history),
2521
mode=self.bzrdir._get_file_mode())
2524
def set_revision_history(self, rev_history):
2525
"""See Branch.set_revision_history."""
2526
if 'evil' in debug.debug_flags:
2527
mutter_callsite(3, "set_revision_history scales with history.")
2528
check_not_reserved_id = _mod_revision.check_not_reserved_id
2529
for rev_id in rev_history:
2530
check_not_reserved_id(rev_id)
2531
if Branch.hooks['post_change_branch_tip']:
2532
# Don't calculate the last_revision_info() if there are no hooks
2534
old_revno, old_revid = self.last_revision_info()
2535
if len(rev_history) == 0:
2536
revid = _mod_revision.NULL_REVISION
2538
revid = rev_history[-1]
2539
self._run_pre_change_branch_tip_hooks(len(rev_history), revid)
2540
self._write_revision_history(rev_history)
2541
self._clear_cached_state()
2542
self._cache_revision_history(rev_history)
2543
for hook in Branch.hooks['set_rh']:
2544
hook(self, rev_history)
2545
if Branch.hooks['post_change_branch_tip']:
2546
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2548
def _synchronize_history(self, destination, revision_id):
2549
"""Synchronize last revision and revision history between branches.
2551
This version is most efficient when the destination is also a
2552
BzrBranch5, but works for BzrBranch6 as long as the revision
2553
history is the true lefthand parent history, and all of the revisions
2554
are in the destination's repository. If not, set_revision_history
2557
:param destination: The branch to copy the history into
2558
:param revision_id: The revision-id to truncate history at. May
2559
be None to copy complete history.
2561
if not isinstance(destination._format, BzrBranchFormat5):
2562
super(BzrBranch, self)._synchronize_history(
2563
destination, revision_id)
2565
if revision_id == _mod_revision.NULL_REVISION:
2568
new_history = self.revision_history()
2569
if revision_id is not None and new_history != []:
2571
new_history = new_history[:new_history.index(revision_id) + 1]
2573
rev = self.repository.get_revision(revision_id)
2574
new_history = rev.get_history(self.repository)[1:]
2575
destination.set_revision_history(new_history)
2577
2514
@needs_write_lock
2578
2515
def set_last_revision_info(self, revno, revision_id):
2579
"""Set the last revision of this branch.
2581
The caller is responsible for checking that the revno is correct
2582
for this revision id.
2584
It may be possible to set the branch last revision to an id not
2585
present in the repository. However, branches can also be
2586
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)
2589
2518
revision_id = _mod_revision.ensure_null(revision_id)
2590
# this old format stores the full history, but this api doesn't
2591
# provide it, so we must generate, and might as well check it's
2593
history = self._lefthand_history(revision_id)
2594
if len(history) != revno:
2595
raise AssertionError('%d != %d' % (len(history), revno))
2596
self.set_revision_history(history)
2598
def _gen_revision_history(self):
2599
history = self._transport.get_bytes('revision-history').split('\n')
2600
if history[-1:] == ['']:
2601
# There shouldn't be a trailing newline, but just in case.
2606
def generate_revision_history(self, revision_id, last_rev=None,
2608
"""Create a new revision history that will finish with revision_id.
2610
:param revision_id: the new tip to use.
2611
:param last_rev: The previous last_revision. If not None, then this
2612
must be a ancestory of revision_id, or DivergedBranches is raised.
2613
:param other_branch: The other branch that DivergedBranches should
2614
raise with respect to.
2616
self.set_revision_history(self._lefthand_history(revision_id,
2617
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)
2619
2528
def basis_tree(self):
2620
2529
"""See Branch.basis_tree."""
2632
def _basic_push(self, target, overwrite, stop_revision):
2633
"""Basic implementation of push without bound branches or hooks.
2635
Must be called with source read locked and target write locked.
2637
result = BranchPushResult()
2638
result.source_branch = self
2639
result.target_branch = target
2640
result.old_revno, result.old_revid = target.last_revision_info()
2641
self.update_references(target)
2642
if result.old_revid != self.last_revision():
2643
# We assume that during 'push' this repository is closer than
2645
graph = self.repository.get_graph(target.repository)
2646
target.update_revisions(self, stop_revision,
2647
overwrite=overwrite, graph=graph)
2648
if self._push_should_merge_tags():
2649
result.tag_conflicts = self.tags.merge_to(target.tags,
2651
result.new_revno, result.new_revid = target.last_revision_info()
2654
2541
def get_stacked_on_url(self):
2655
2542
raise errors.UnstackableBranchFormat(self._format, self.user_url)
2667
2554
self._transport.put_bytes('parent', url + '\n',
2668
2555
mode=self.bzrdir._get_file_mode())
2671
class BzrBranch5(BzrBranch):
2672
"""A format 5 branch. This supports new features over plain branches.
2674
It has support for a master_branch which is the data for bound branches.
2677
def get_bound_location(self):
2679
return self._transport.get_bytes('bound')[:-1]
2680
except errors.NoSuchFile:
2684
def get_master_branch(self, possible_transports=None):
2685
"""Return the branch we are bound to.
2687
:return: Either a Branch, or None
2689
This could memoise the branch, but if thats done
2690
it must be revalidated on each new lock.
2691
So for now we just don't memoise it.
2692
# RBC 20060304 review this decision.
2694
bound_loc = self.get_bound_location()
2698
return Branch.open(bound_loc,
2699
possible_transports=possible_transports)
2700
except (errors.NotBranchError, errors.ConnectionError), e:
2701
raise errors.BoundBranchConnectionFailure(
2704
2557
@needs_write_lock
2705
def set_bound_location(self, location):
2706
"""Set the target where this branch is bound to.
2708
:param location: URL to the target branch
2711
self._transport.put_bytes('bound', location+'\n',
2712
mode=self.bzrdir._get_file_mode())
2715
self._transport.delete('bound')
2716
except errors.NoSuchFile:
2559
"""If bound, unbind"""
2560
return self.set_bound_location(None)
2720
2562
@needs_write_lock
2721
2563
def bind(self, other):
2743
2585
# history around
2744
2586
self.set_bound_location(other.base)
2588
def get_bound_location(self):
2590
return self._transport.get_bytes('bound')[:-1]
2591
except errors.NoSuchFile:
2595
def get_master_branch(self, possible_transports=None):
2596
"""Return the branch we are bound to.
2598
:return: Either a Branch, or None
2600
if self._master_branch_cache is None:
2601
self._master_branch_cache = self._get_master_branch(
2602
possible_transports)
2603
return self._master_branch_cache
2605
def _get_master_branch(self, possible_transports):
2606
bound_loc = self.get_bound_location()
2610
return Branch.open(bound_loc,
2611
possible_transports=possible_transports)
2612
except (errors.NotBranchError, errors.ConnectionError), e:
2613
raise errors.BoundBranchConnectionFailure(
2746
2616
@needs_write_lock
2748
"""If bound, unbind"""
2749
return self.set_bound_location(None)
2617
def set_bound_location(self, location):
2618
"""Set the target where this branch is bound to.
2620
:param location: URL to the target branch
2622
self._master_branch_cache = None
2624
self._transport.put_bytes('bound', location+'\n',
2625
mode=self.bzrdir._get_file_mode())
2628
self._transport.delete('bound')
2629
except errors.NoSuchFile:
2751
2633
@needs_write_lock
2752
2634
def update(self, possible_transports=None):
2769
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):
2770
2779
"""A branch that stores tree-reference locations."""
2772
2781
def _open_hook(self):
2798
2807
self._last_revision_info_cache = None
2799
2808
self._reference_info = None
2801
def _last_revision_info(self):
2802
revision_string = self._transport.get_bytes('last-revision')
2803
revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
2804
revision_id = cache_utf8.get_cached_utf8(revision_id)
2806
return revno, revision_id
2808
def _write_last_revision_info(self, revno, revision_id):
2809
"""Simply write out the revision id, with no checks.
2811
Use set_last_revision_info to perform this safely.
2813
Does not update the revision_history cache.
2814
Intended to be called by set_last_revision_info and
2815
_write_revision_history.
2817
revision_id = _mod_revision.ensure_null(revision_id)
2818
out_string = '%d %s\n' % (revno, revision_id)
2819
self._transport.put_bytes('last-revision', out_string,
2820
mode=self.bzrdir._get_file_mode())
2823
def set_last_revision_info(self, revno, revision_id):
2824
revision_id = _mod_revision.ensure_null(revision_id)
2825
old_revno, old_revid = self.last_revision_info()
2826
if self._get_append_revisions_only():
2827
self._check_history_violation(revision_id)
2828
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2829
self._write_last_revision_info(revno, revision_id)
2830
self._clear_cached_state()
2831
self._last_revision_info_cache = revno, revision_id
2832
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2834
def _synchronize_history(self, destination, revision_id):
2835
"""Synchronize last revision and revision history between branches.
2837
:see: Branch._synchronize_history
2839
# XXX: The base Branch has a fast implementation of this method based
2840
# on set_last_revision_info, but BzrBranch/BzrBranch5 have a slower one
2841
# that uses set_revision_history. This class inherits from BzrBranch5,
2842
# but wants the fast implementation, so it calls
2843
# Branch._synchronize_history directly.
2844
Branch._synchronize_history(self, destination, revision_id)
2846
2810
def _check_history_violation(self, revision_id):
2847
2811
last_revision = _mod_revision.ensure_null(self.last_revision())
2848
2812
if _mod_revision.is_null(last_revision):
3362
3308
self.source.tags.merge_to(self.target.tags)
3364
3310
@needs_write_lock
3365
def update_revisions(self, stop_revision=None, overwrite=False,
3367
"""See InterBranch.update_revisions()."""
3311
def fetch(self, stop_revision=None):
3312
if self.target.base == self.source.base:
3314
self.source.lock_read()
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)
3326
self.source.unlock()
3329
def _update_revisions(self, stop_revision=None, overwrite=False,
3368
3331
other_revno, other_last_revision = self.source.last_revision_info()
3369
3332
stop_revno = None # unknown
3370
3333
if stop_revision is None:
3455
3420
self.source.unlock()
3422
def _basic_push(self, overwrite, stop_revision):
3423
"""Basic implementation of push without bound branches or hooks.
3425
Must be called with source read locked and target write locked.
3427
result = BranchPushResult()
3428
result.source_branch = self.source
3429
result.target_branch = self.target
3430
result.old_revno, result.old_revid = self.target.last_revision_info()
3431
self.source.update_references(self.target)
3432
if result.old_revid != stop_revision:
3433
# We assume that during 'push' this repository is closer than
3435
graph = self.source.repository.get_graph(self.target.repository)
3436
self._update_revisions(stop_revision, overwrite=overwrite,
3438
if self.source._push_should_merge_tags():
3439
result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
3441
result.new_revno, result.new_revid = self.target.last_revision_info()
3457
3444
def _push_with_bound_branches(self, overwrite, stop_revision,
3458
3445
_override_hook_source_branch=None):
3459
3446
"""Push from source into target, and into target's master if any.
3474
3461
master_branch.lock_write()
3476
3463
# push into the master from the source branch.
3477
self.source._basic_push(master_branch, overwrite, stop_revision)
3478
# and push into the target branch from the source. Note that we
3479
# push from the source branch again, because its considered the
3480
# highest bandwidth repository.
3481
result = self.source._basic_push(self.target, overwrite,
3464
master_inter = InterBranch.get(self.source, master_branch)
3465
master_inter._basic_push(overwrite, stop_revision)
3466
# and push into the target branch from the source. Note that
3467
# we push from the source branch again, because it's considered
3468
# the highest bandwidth repository.
3469
result = self._basic_push(overwrite, stop_revision)
3483
3470
result.master_branch = master_branch
3484
3471
result.local_branch = self.target
added
removed
bzrlib/branch.py
