649
669
raise errors.UnsupportedOperation(self.get_reference_info, self)
651
671
@needs_write_lock
652
def fetch(self, from_branch, last_revision=None, pb=None):
672
def fetch(self, from_branch, last_revision=None):
653
673
"""Copy revisions from from_branch into this branch.
655
675
:param from_branch: Where to copy from.
656
676
:param last_revision: What revision to stop at (None for at the end
658
:param pb: An optional progress bar to use.
661
if self.base == from_branch.base:
664
symbol_versioning.warn(
665
symbol_versioning.deprecated_in((1, 14, 0))
666
% "pb parameter to fetch()")
667
from_branch.lock_read()
669
if last_revision is None:
670
last_revision = from_branch.last_revision()
671
last_revision = _mod_revision.ensure_null(last_revision)
672
return self.repository.fetch(from_branch.repository,
673
revision_id=last_revision,
680
return InterBranch.get(from_branch, self).fetch(last_revision)
678
682
def get_bound_location(self):
679
683
"""Return the URL of the branch we are bound to.
739
746
"""Print `file` to stdout."""
740
747
raise NotImplementedError(self.print_file)
749
@deprecated_method(deprecated_in((2, 4, 0)))
742
750
def set_revision_history(self, rev_history):
743
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)
745
791
@needs_write_lock
746
792
def set_parent(self, url):
859
906
# XXX: If you unstack a branch while it has a working tree
860
907
# with a pending merge, the pending-merged revisions will no
861
908
# longer be present. You can (probably) revert and remerge.
863
# XXX: This only fetches up to the tip of the repository; it
864
# doesn't bring across any tags. That's fairly consistent
865
# with how branch works, but perhaps not ideal.
866
self.repository.fetch(old_repository,
867
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)
870
918
old_repository.unlock()
968
1022
:return: A tuple (revno, revision_id).
970
1024
if self._last_revision_info_cache is None:
971
self._last_revision_info_cache = self._last_revision_info()
1025
self._last_revision_info_cache = self._read_last_revision_info()
972
1026
return self._last_revision_info_cache
974
def _last_revision_info(self):
975
rh = self.revision_history()
978
return (revno, rh[-1])
980
return (0, _mod_revision.NULL_REVISION)
982
@deprecated_method(deprecated_in((1, 6, 0)))
983
def missing_revisions(self, other, stop_revision=None):
984
"""Return a list of new revisions that would perfectly fit.
986
If self and other have not diverged, return a list of the revisions
987
present in other, but missing from self.
989
self_history = self.revision_history()
990
self_len = len(self_history)
991
other_history = other.revision_history()
992
other_len = len(other_history)
993
common_index = min(self_len, other_len) -1
994
if common_index >= 0 and \
995
self_history[common_index] != other_history[common_index]:
996
raise errors.DivergedBranches(self, other)
998
if stop_revision is None:
999
stop_revision = other_len
1001
if stop_revision > other_len:
1002
raise errors.NoSuchRevision(self, stop_revision)
1003
return other_history[self_len:stop_revision]
1005
def update_revisions(self, other, stop_revision=None, overwrite=False,
1007
"""Pull in new perfect-fit revisions.
1009
:param other: Another Branch to pull from
1010
:param stop_revision: Updated until the given revision
1011
:param overwrite: Always set the branch pointer, rather than checking
1012
to see if it is a proper descendant.
1013
:param graph: A Graph object that can be used to query history
1014
information. This can be None.
1017
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)))
1020
1032
def import_last_revision_info(self, source_repo, revno, revid):
1021
1033
"""Set the last revision info, importing from another repo if necessary.
1023
This is used by the bound branch code to upload a revision to
1024
the master branch first before updating the tip of the local branch.
1026
1035
:param source_repo: Source repository to optionally fetch from
1027
1036
:param revno: Revision number of the new tip
1028
1037
:param revid: Revision id of the new tip
1031
1040
self.repository.fetch(source_repo, revision_id=revid)
1032
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)
1034
1064
def revision_id_to_revno(self, revision_id):
1035
1065
"""Given a revision id, return its revno"""
1036
1066
if _mod_revision.is_null(revision_id):
1362
1397
"""Return the most suitable metadir for a checkout of this branch.
1363
1398
Weaves are used if this branch's repository uses weaves.
1365
if isinstance(self.bzrdir, bzrdir.BzrDirPreSplitOut):
1366
from bzrlib.repofmt import weaverepo
1367
format = bzrdir.BzrDirMetaFormat1()
1368
format.repository_format = weaverepo.RepositoryFormat7()
1370
format = self.repository.bzrdir.checkout_metadir()
1371
format.set_branch_format(self._format)
1400
format = self.repository.bzrdir.checkout_metadir()
1401
format.set_branch_format(self._format)
1374
1404
def create_clone_on_transport(self, to_transport, revision_id=None,
1375
stacked_on=None, create_prefix=False, use_existing_dir=False):
1405
stacked_on=None, create_prefix=False, use_existing_dir=False,
1376
1407
"""Create a clone of this branch and its bzrdir.
1378
1409
:param to_transport: The transport to clone onto.
1513
1545
raise AssertionError("invalid heads: %r" % (heads,))
1516
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):
1517
1569
"""An encapsulation of the initialization and open routines for a format.
1519
1571
Formats provide three things:
1552
1598
transport = a_bzrdir.get_branch_transport(None, name=name)
1553
1599
format_string = transport.get_bytes("format")
1554
format = klass._formats[format_string]
1555
if isinstance(format, MetaDirBranchFormatFactory):
1600
return format_registry.get(format_string)
1558
1601
except errors.NoSuchFile:
1559
1602
raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1560
1603
except KeyError:
1561
1604
raise errors.UnknownFormatError(format=format_string, kind='branch')
1607
@deprecated_method(deprecated_in((2, 4, 0)))
1564
1608
def get_default_format(klass):
1565
1609
"""Return the current default format."""
1566
return klass._default_format
1610
return format_registry.get_default()
1613
@deprecated_method(deprecated_in((2, 4, 0)))
1569
1614
def get_formats(klass):
1570
1615
"""Get all the known formats.
1572
1617
Warning: This triggers a load of all lazy registered formats: do not
1573
1618
use except when that is desireed.
1576
for fmt in klass._formats.values():
1577
if isinstance(fmt, MetaDirBranchFormatFactory):
1620
return format_registry._get_all()
1582
1622
def get_reference(self, a_bzrdir, name=None):
1583
1623
"""Get the target reference of the branch in a_bzrdir.
1622
1662
for hook in hooks:
1625
def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
1626
lock_type='metadir', set_format=True):
1627
"""Initialize a branch in a bzrdir, with specified files
1629
:param a_bzrdir: The bzrdir to initialize the branch in
1630
:param utf8_files: The files to create as a list of
1631
(filename, content) tuples
1632
:param name: Name of colocated branch to create, if any
1633
:param set_format: If True, set the format with
1634
self.get_format_string. (BzrBranch4 has its format set
1636
:return: a branch in this format
1638
mutter('creating branch %r in %s', self, a_bzrdir.user_url)
1639
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1641
'metadir': ('lock', lockdir.LockDir),
1642
'branch4': ('branch-lock', lockable_files.TransportLock),
1644
lock_name, lock_class = lock_map[lock_type]
1645
control_files = lockable_files.LockableFiles(branch_transport,
1646
lock_name, lock_class)
1647
control_files.create_lock()
1649
control_files.lock_write()
1650
except errors.LockContention:
1651
if lock_type != 'branch4':
1657
utf8_files += [('format', self.get_format_string())]
1659
for (filename, content) in utf8_files:
1660
branch_transport.put_bytes(
1662
mode=a_bzrdir._get_file_mode())
1665
control_files.unlock()
1666
branch = self.open(a_bzrdir, name, _found=True)
1667
self._run_post_branch_init_hooks(a_bzrdir, name, branch)
1670
def initialize(self, a_bzrdir, name=None):
1665
def initialize(self, a_bzrdir, name=None, repository=None):
1671
1666
"""Create a branch of this format in a_bzrdir.
1673
1668
:param name: Name of the colocated branch to create.
1720
1716
raise NotImplementedError(self.open)
1719
@deprecated_method(deprecated_in((2, 4, 0)))
1723
1720
def register_format(klass, format):
1724
1721
"""Register a metadir format.
1726
1723
See MetaDirBranchFormatFactory for the ability to register a format
1727
1724
without loading the code the format needs until it is actually used.
1729
klass._formats[format.get_format_string()] = format
1730
# Metadir formats have a network name of their format string, and get
1731
# registered as factories.
1732
if isinstance(format, MetaDirBranchFormatFactory):
1733
network_format_registry.register(format.get_format_string(), format)
1735
network_format_registry.register(format.get_format_string(),
1726
format_registry.register(format)
1729
@deprecated_method(deprecated_in((2, 4, 0)))
1739
1730
def set_default_format(klass, format):
1740
klass._default_format = format
1731
format_registry.set_default(format)
1742
1733
def supports_set_append_revisions_only(self):
1743
1734
"""True if this format supports set_append_revisions_only."""
1800
1796
These are all empty initially, because by default nothing should get
1803
Hooks.__init__(self)
1804
self.create_hook(HookPoint('set_rh',
1799
Hooks.__init__(self, "bzrlib.branch", "Branch.hooks")
1800
self.add_hook('set_rh',
1805
1801
"Invoked whenever the revision history has been set via "
1806
1802
"set_revision_history. The api signature is (branch, "
1807
1803
"revision_history), and the branch will be write-locked. "
1808
1804
"The set_rh hook can be expensive for bzr to trigger, a better "
1809
"hook to use is Branch.post_change_branch_tip.", (0, 15), None))
1810
self.create_hook(HookPoint('open',
1805
"hook to use is Branch.post_change_branch_tip.", (0, 15))
1806
self.add_hook('open',
1811
1807
"Called with the Branch object that has been opened after a "
1812
"branch is opened.", (1, 8), None))
1813
self.create_hook(HookPoint('post_push',
1808
"branch is opened.", (1, 8))
1809
self.add_hook('post_push',
1814
1810
"Called after a push operation completes. post_push is called "
1815
1811
"with a bzrlib.branch.BranchPushResult object and only runs in the "
1816
"bzr client.", (0, 15), None))
1817
self.create_hook(HookPoint('post_pull',
1812
"bzr client.", (0, 15))
1813
self.add_hook('post_pull',
1818
1814
"Called after a pull operation completes. post_pull is called "
1819
1815
"with a bzrlib.branch.PullResult object and only runs in the "
1820
"bzr client.", (0, 15), None))
1821
self.create_hook(HookPoint('pre_commit',
1822
"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 "
1823
1819
"completed. pre_commit is called with (local, master, old_revno, "
1824
1820
"old_revid, future_revno, future_revid, tree_delta, future_tree"
1825
1821
"). old_revid is NULL_REVISION for the first commit to a branch, "
1827
1823
"basis revision. hooks MUST NOT modify this delta. "
1828
1824
" future_tree is an in-memory tree obtained from "
1829
1825
"CommitBuilder.revision_tree() and hooks MUST NOT modify this "
1830
"tree.", (0,91), None))
1831
self.create_hook(HookPoint('post_commit',
1827
self.add_hook('post_commit',
1832
1828
"Called in the bzr client after a commit has completed. "
1833
1829
"post_commit is called with (local, master, old_revno, old_revid, "
1834
1830
"new_revno, new_revid). old_revid is NULL_REVISION for the first "
1835
"commit to a branch.", (0, 15), None))
1836
self.create_hook(HookPoint('post_uncommit',
1831
"commit to a branch.", (0, 15))
1832
self.add_hook('post_uncommit',
1837
1833
"Called in the bzr client after an uncommit completes. "
1838
1834
"post_uncommit is called with (local, master, old_revno, "
1839
1835
"old_revid, new_revno, new_revid) where local is the local branch "
1840
1836
"or None, master is the target branch, and an empty branch "
1841
"receives new_revno of 0, new_revid of None.", (0, 15), None))
1842
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',
1843
1839
"Called in bzr client and server before a change to the tip of a "
1844
1840
"branch is made. pre_change_branch_tip is called with a "
1845
1841
"bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1846
"commit, uncommit will all trigger this hook.", (1, 6), None))
1847
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',
1848
1844
"Called in bzr client and server after a change to the tip of a "
1849
1845
"branch is made. post_change_branch_tip is called with a "
1850
1846
"bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1851
"commit, uncommit will all trigger this hook.", (1, 4), None))
1852
self.create_hook(HookPoint('transform_fallback_location',
1847
"commit, uncommit will all trigger this hook.", (1, 4))
1848
self.add_hook('transform_fallback_location',
1853
1849
"Called when a stacked branch is activating its fallback "
1854
1850
"locations. transform_fallback_location is called with (branch, "
1855
1851
"url), and should return a new url. Returning the same url "
1860
1856
"fallback locations have not been activated. When there are "
1861
1857
"multiple hooks installed for transform_fallback_location, "
1862
1858
"all are called with the url returned from the previous hook."
1863
"The order is however undefined.", (1, 9), None))
1864
self.create_hook(HookPoint('automatic_tag_name',
1859
"The order is however undefined.", (1, 9))
1860
self.add_hook('automatic_tag_name',
1865
1861
"Called to determine an automatic tag name for a revision. "
1866
1862
"automatic_tag_name is called with (branch, revision_id) and "
1867
1863
"should return a tag name or None if no tag name could be "
1868
1864
"determined. The first non-None tag name returned will be used.",
1870
self.create_hook(HookPoint('post_branch_init',
1866
self.add_hook('post_branch_init',
1871
1867
"Called after new branch initialization completes. "
1872
1868
"post_branch_init is called with a "
1873
1869
"bzrlib.branch.BranchInitHookParams. "
1874
1870
"Note that init, branch and checkout (both heavyweight and "
1875
"lightweight) will all trigger this hook.", (2, 2), None))
1876
self.create_hook(HookPoint('post_switch',
1871
"lightweight) will all trigger this hook.", (2, 2))
1872
self.add_hook('post_switch',
1877
1873
"Called after a checkout switches branch. "
1878
1874
"post_switch is called with a "
1879
"bzrlib.branch.SwitchHookParams.", (2, 2), None))
1875
"bzrlib.branch.SwitchHookParams.", (2, 2))
1995
1991
self.revision_id)
1998
class BzrBranchFormat4(BranchFormat):
1999
"""Bzr branch format 4.
2002
- a revision-history file.
2003
- a branch-lock lock file [ to be shared with the bzrdir ]
2006
def get_format_description(self):
2007
"""See BranchFormat.get_format_description()."""
2008
return "Branch format 4"
2010
def initialize(self, a_bzrdir, name=None):
2011
"""Create a branch of this format in a_bzrdir."""
2012
utf8_files = [('revision-history', ''),
2013
('branch-name', ''),
2015
return self._initialize_helper(a_bzrdir, utf8_files, name=name,
2016
lock_type='branch4', set_format=False)
2019
super(BzrBranchFormat4, self).__init__()
2020
self._matchingbzrdir = bzrdir.BzrDirFormat6()
2022
def network_name(self):
2023
"""The network name for this format is the control dirs disk label."""
2024
return self._matchingbzrdir.get_format_string()
2026
def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
2027
"""See BranchFormat.open()."""
2029
# we are being called directly and must probe.
2030
raise NotImplementedError
2031
return BzrBranch(_format=self,
2032
_control_files=a_bzrdir._control_files,
2035
_repository=a_bzrdir.open_repository())
2038
return "Bazaar-NG branch format 4"
2041
1994
class BranchFormatMetadir(BranchFormat):
2042
1995
"""Common logic for meta-dir based branch formats."""
2045
1998
"""What class to instantiate on open calls."""
2046
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)
2048
2030
def network_name(self):
2049
2031
"""A simple byte string uniquely identifying this format for RPC calls.
2168
2156
"""See BranchFormat.get_format_description()."""
2169
2157
return "Branch format 8"
2171
def initialize(self, a_bzrdir, name=None):
2159
def initialize(self, a_bzrdir, name=None, repository=None):
2172
2160
"""Create a branch of this format in a_bzrdir."""
2173
2161
utf8_files = [('last-revision', '0 null:\n'),
2174
2162
('branch.conf', ''),
2176
2164
('references', '')
2178
return self._initialize_helper(a_bzrdir, utf8_files, name)
2181
super(BzrBranchFormat8, self).__init__()
2182
self._matchingbzrdir.repository_format = \
2183
RepositoryFormatKnitPack5RichRoot()
2166
return self._initialize_helper(a_bzrdir, utf8_files, name, repository)
2185
2168
def make_tags(self, branch):
2186
2169
"""See bzrlib.branch.BranchFormat.make_tags()."""
2344
2352
__format6 = BzrBranchFormat6()
2345
2353
__format7 = BzrBranchFormat7()
2346
2354
__format8 = BzrBranchFormat8()
2347
BranchFormat.register_format(__format5)
2348
BranchFormat.register_format(BranchReferenceFormat())
2349
BranchFormat.register_format(__format6)
2350
BranchFormat.register_format(__format7)
2351
BranchFormat.register_format(__format8)
2352
BranchFormat.set_default_format(__format7)
2353
_legacy_formats = [BzrBranchFormat4(),
2355
network_format_registry.register(
2356
_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)
2359
2363
class BranchWriteLockResult(LogicalLockResult):
2507
2511
"""See Branch.print_file."""
2508
2512
return self.repository.print_file(file, revision_id)
2510
def _write_revision_history(self, history):
2511
"""Factored out of set_revision_history.
2513
This performs the actual writing to disk.
2514
It is intended to be called by BzrBranch5.set_revision_history."""
2515
self._transport.put_bytes(
2516
'revision-history', '\n'.join(history),
2517
mode=self.bzrdir._get_file_mode())
2520
def set_revision_history(self, rev_history):
2521
"""See Branch.set_revision_history."""
2522
if 'evil' in debug.debug_flags:
2523
mutter_callsite(3, "set_revision_history scales with history.")
2524
check_not_reserved_id = _mod_revision.check_not_reserved_id
2525
for rev_id in rev_history:
2526
check_not_reserved_id(rev_id)
2527
if Branch.hooks['post_change_branch_tip']:
2528
# Don't calculate the last_revision_info() if there are no hooks
2530
old_revno, old_revid = self.last_revision_info()
2531
if len(rev_history) == 0:
2532
revid = _mod_revision.NULL_REVISION
2534
revid = rev_history[-1]
2535
self._run_pre_change_branch_tip_hooks(len(rev_history), revid)
2536
self._write_revision_history(rev_history)
2537
self._clear_cached_state()
2538
self._cache_revision_history(rev_history)
2539
for hook in Branch.hooks['set_rh']:
2540
hook(self, rev_history)
2541
if Branch.hooks['post_change_branch_tip']:
2542
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2544
def _synchronize_history(self, destination, revision_id):
2545
"""Synchronize last revision and revision history between branches.
2547
This version is most efficient when the destination is also a
2548
BzrBranch5, but works for BzrBranch6 as long as the revision
2549
history is the true lefthand parent history, and all of the revisions
2550
are in the destination's repository. If not, set_revision_history
2553
:param destination: The branch to copy the history into
2554
:param revision_id: The revision-id to truncate history at. May
2555
be None to copy complete history.
2557
if not isinstance(destination._format, BzrBranchFormat5):
2558
super(BzrBranch, self)._synchronize_history(
2559
destination, revision_id)
2561
if revision_id == _mod_revision.NULL_REVISION:
2564
new_history = self.revision_history()
2565
if revision_id is not None and new_history != []:
2567
new_history = new_history[:new_history.index(revision_id) + 1]
2569
rev = self.repository.get_revision(revision_id)
2570
new_history = rev.get_history(self.repository)[1:]
2571
destination.set_revision_history(new_history)
2573
2514
@needs_write_lock
2574
2515
def set_last_revision_info(self, revno, revision_id):
2575
"""Set the last revision of this branch.
2577
The caller is responsible for checking that the revno is correct
2578
for this revision id.
2580
It may be possible to set the branch last revision to an id not
2581
present in the repository. However, branches can also be
2582
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)
2585
2518
revision_id = _mod_revision.ensure_null(revision_id)
2586
# this old format stores the full history, but this api doesn't
2587
# provide it, so we must generate, and might as well check it's
2589
history = self._lefthand_history(revision_id)
2590
if len(history) != revno:
2591
raise AssertionError('%d != %d' % (len(history), revno))
2592
self.set_revision_history(history)
2594
def _gen_revision_history(self):
2595
history = self._transport.get_bytes('revision-history').split('\n')
2596
if history[-1:] == ['']:
2597
# There shouldn't be a trailing newline, but just in case.
2602
def generate_revision_history(self, revision_id, last_rev=None,
2604
"""Create a new revision history that will finish with revision_id.
2606
:param revision_id: the new tip to use.
2607
:param last_rev: The previous last_revision. If not None, then this
2608
must be a ancestory of revision_id, or DivergedBranches is raised.
2609
:param other_branch: The other branch that DivergedBranches should
2610
raise with respect to.
2612
self.set_revision_history(self._lefthand_history(revision_id,
2613
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)
2615
2528
def basis_tree(self):
2616
2529
"""See Branch.basis_tree."""
2628
def _basic_push(self, target, overwrite, stop_revision):
2629
"""Basic implementation of push without bound branches or hooks.
2631
Must be called with source read locked and target write locked.
2633
result = BranchPushResult()
2634
result.source_branch = self
2635
result.target_branch = target
2636
result.old_revno, result.old_revid = target.last_revision_info()
2637
self.update_references(target)
2638
if result.old_revid != self.last_revision():
2639
# We assume that during 'push' this repository is closer than
2641
graph = self.repository.get_graph(target.repository)
2642
target.update_revisions(self, stop_revision,
2643
overwrite=overwrite, graph=graph)
2644
if self._push_should_merge_tags():
2645
result.tag_conflicts = self.tags.merge_to(target.tags,
2647
result.new_revno, result.new_revid = target.last_revision_info()
2650
2541
def get_stacked_on_url(self):
2651
2542
raise errors.UnstackableBranchFormat(self._format, self.user_url)
2663
2554
self._transport.put_bytes('parent', url + '\n',
2664
2555
mode=self.bzrdir._get_file_mode())
2667
class BzrBranch5(BzrBranch):
2668
"""A format 5 branch. This supports new features over plain branches.
2670
It has support for a master_branch which is the data for bound branches.
2673
def get_bound_location(self):
2675
return self._transport.get_bytes('bound')[:-1]
2676
except errors.NoSuchFile:
2680
def get_master_branch(self, possible_transports=None):
2681
"""Return the branch we are bound to.
2683
:return: Either a Branch, or None
2685
This could memoise the branch, but if thats done
2686
it must be revalidated on each new lock.
2687
So for now we just don't memoise it.
2688
# RBC 20060304 review this decision.
2690
bound_loc = self.get_bound_location()
2694
return Branch.open(bound_loc,
2695
possible_transports=possible_transports)
2696
except (errors.NotBranchError, errors.ConnectionError), e:
2697
raise errors.BoundBranchConnectionFailure(
2700
2557
@needs_write_lock
2701
def set_bound_location(self, location):
2702
"""Set the target where this branch is bound to.
2704
:param location: URL to the target branch
2707
self._transport.put_bytes('bound', location+'\n',
2708
mode=self.bzrdir._get_file_mode())
2711
self._transport.delete('bound')
2712
except errors.NoSuchFile:
2559
"""If bound, unbind"""
2560
return self.set_bound_location(None)
2716
2562
@needs_write_lock
2717
2563
def bind(self, other):
2739
2585
# history around
2740
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(
2742
2616
@needs_write_lock
2744
"""If bound, unbind"""
2745
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:
2747
2633
@needs_write_lock
2748
2634
def update(self, possible_transports=None):
2765
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):
2766
2779
"""A branch that stores tree-reference locations."""
2768
2781
def _open_hook(self):
2794
2807
self._last_revision_info_cache = None
2795
2808
self._reference_info = None
2797
def _last_revision_info(self):
2798
revision_string = self._transport.get_bytes('last-revision')
2799
revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
2800
revision_id = cache_utf8.get_cached_utf8(revision_id)
2802
return revno, revision_id
2804
def _write_last_revision_info(self, revno, revision_id):
2805
"""Simply write out the revision id, with no checks.
2807
Use set_last_revision_info to perform this safely.
2809
Does not update the revision_history cache.
2810
Intended to be called by set_last_revision_info and
2811
_write_revision_history.
2813
revision_id = _mod_revision.ensure_null(revision_id)
2814
out_string = '%d %s\n' % (revno, revision_id)
2815
self._transport.put_bytes('last-revision', out_string,
2816
mode=self.bzrdir._get_file_mode())
2819
def set_last_revision_info(self, revno, revision_id):
2820
revision_id = _mod_revision.ensure_null(revision_id)
2821
old_revno, old_revid = self.last_revision_info()
2822
if self._get_append_revisions_only():
2823
self._check_history_violation(revision_id)
2824
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2825
self._write_last_revision_info(revno, revision_id)
2826
self._clear_cached_state()
2827
self._last_revision_info_cache = revno, revision_id
2828
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2830
def _synchronize_history(self, destination, revision_id):
2831
"""Synchronize last revision and revision history between branches.
2833
:see: Branch._synchronize_history
2835
# XXX: The base Branch has a fast implementation of this method based
2836
# on set_last_revision_info, but BzrBranch/BzrBranch5 have a slower one
2837
# that uses set_revision_history. This class inherits from BzrBranch5,
2838
# but wants the fast implementation, so it calls
2839
# Branch._synchronize_history directly.
2840
Branch._synchronize_history(self, destination, revision_id)
2842
2810
def _check_history_violation(self, revision_id):
2843
2811
last_revision = _mod_revision.ensure_null(self.last_revision())
2844
2812
if _mod_revision.is_null(last_revision):
3358
3308
self.source.tags.merge_to(self.target.tags)
3360
3310
@needs_write_lock
3361
def update_revisions(self, stop_revision=None, overwrite=False,
3363
"""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,
3364
3331
other_revno, other_last_revision = self.source.last_revision_info()
3365
3332
stop_revno = None # unknown
3366
3333
if stop_revision is None:
3451
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()
3453
3444
def _push_with_bound_branches(self, overwrite, stop_revision,
3454
3445
_override_hook_source_branch=None):
3455
3446
"""Push from source into target, and into target's master if any.
3470
3461
master_branch.lock_write()
3472
3463
# push into the master from the source branch.
3473
self.source._basic_push(master_branch, overwrite, stop_revision)
3474
# and push into the target branch from the source. Note that we
3475
# push from the source branch again, because its considered the
3476
# highest bandwidth repository.
3477
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)
3479
3470
result.master_branch = master_branch
3480
3471
result.local_branch = self.target
added
removed
bzrlib/branch.py
