43
44
from bzrlib.config import BranchConfig, TransportConfig
44
from bzrlib.repofmt.pack_repo import RepositoryFormatKnitPack5RichRoot
45
45
from bzrlib.tag import (
51
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
52
from bzrlib.hooks import HookPoint, Hooks
54
from bzrlib.decorators import (
59
from bzrlib.hooks import Hooks
53
60
from bzrlib.inter import InterObject
54
61
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
55
62
from bzrlib import registry
106
115
def _activate_fallback_location(self, url):
107
116
"""Activate the branch/repository from url as a fallback repository."""
117
for existing_fallback_repo in self.repository._fallback_repositories:
118
if existing_fallback_repo.user_url == url:
119
# This fallback is already configured. This probably only
120
# happens because BzrDir.sprout is a horrible mess. To avoid
121
# confusing _unstack we don't add this a second time.
122
mutter('duplicate activation of fallback %r on %r', url, self)
108
124
repo = self._get_fallback_repository(url)
109
125
if repo.has_same_location(self.repository):
110
126
raise errors.UnstackableLocationError(self.user_url, url)
653
669
raise errors.UnsupportedOperation(self.get_reference_info, self)
655
671
@needs_write_lock
656
def fetch(self, from_branch, last_revision=None, pb=None):
672
def fetch(self, from_branch, last_revision=None):
657
673
"""Copy revisions from from_branch into this branch.
659
675
:param from_branch: Where to copy from.
660
676
:param last_revision: What revision to stop at (None for at the end
662
:param pb: An optional progress bar to use.
665
if self.base == from_branch.base:
668
symbol_versioning.warn(
669
symbol_versioning.deprecated_in((1, 14, 0))
670
% "pb parameter to fetch()")
671
from_branch.lock_read()
673
if last_revision is None:
674
last_revision = from_branch.last_revision()
675
last_revision = _mod_revision.ensure_null(last_revision)
676
return self.repository.fetch(from_branch.repository,
677
revision_id=last_revision,
680
return InterBranch.get(from_branch, self).fetch(last_revision)
682
682
def get_bound_location(self):
683
683
"""Return the URL of the branch we are bound to.
704
704
:param committer: Optional committer to set for commit.
705
705
:param revprops: Optional dictionary of revision properties.
706
706
:param revision_id: Optional revision id.
707
:param lossy: Whether to discard data that can not be natively
708
represented, when pushing to a foreign VCS
709
711
if config is None:
710
712
config = self.get_config()
712
714
return self.repository.get_commit_builder(self, parents, config,
713
timestamp, timezone, committer, revprops, revision_id)
715
timestamp, timezone, committer, revprops, revision_id,
715
718
def get_master_branch(self, possible_transports=None):
716
719
"""Return the branch we are bound to.
809
812
old_repository = self.repository
810
813
if len(old_repository._fallback_repositories) != 1:
811
814
raise AssertionError("can't cope with fallback repositories "
812
"of %r" % (self.repository,))
815
"of %r (fallbacks: %r)" % (old_repository,
816
old_repository._fallback_repositories))
813
817
# Open the new repository object.
814
818
# Repositories don't offer an interface to remove fallback
815
819
# repositories today; take the conceptually simpler option and just
863
867
# XXX: If you unstack a branch while it has a working tree
864
868
# with a pending merge, the pending-merged revisions will no
865
869
# longer be present. You can (probably) revert and remerge.
867
# XXX: This only fetches up to the tip of the repository; it
868
# doesn't bring across any tags. That's fairly consistent
869
# with how branch works, but perhaps not ideal.
870
self.repository.fetch(old_repository,
871
revision_id=self.last_revision(),
871
tags_to_fetch = set(self.tags.get_reverse_tag_dict())
872
except errors.TagsNotSupported:
873
tags_to_fetch = set()
874
fetch_spec = _mod_graph.NotInOtherForRevs(self.repository,
875
old_repository, required_ids=[self.last_revision()],
876
if_present_ids=tags_to_fetch, find_ghosts=True).execute()
877
self.repository.fetch(old_repository, fetch_spec=fetch_spec)
874
879
old_repository.unlock()
989
995
return (0, _mod_revision.NULL_REVISION)
991
@deprecated_method(deprecated_in((1, 6, 0)))
992
def missing_revisions(self, other, stop_revision=None):
993
"""Return a list of new revisions that would perfectly fit.
995
If self and other have not diverged, return a list of the revisions
996
present in other, but missing from self.
998
self_history = self.revision_history()
999
self_len = len(self_history)
1000
other_history = other.revision_history()
1001
other_len = len(other_history)
1002
common_index = min(self_len, other_len) -1
1003
if common_index >= 0 and \
1004
self_history[common_index] != other_history[common_index]:
1005
raise errors.DivergedBranches(self, other)
1007
if stop_revision is None:
1008
stop_revision = other_len
1010
if stop_revision > other_len:
1011
raise errors.NoSuchRevision(self, stop_revision)
1012
return other_history[self_len:stop_revision]
1014
997
def update_revisions(self, other, stop_revision=None, overwrite=False,
1016
999
"""Pull in new perfect-fit revisions.
1018
1001
:param other: Another Branch to pull from
1026
1009
return InterBranch.get(other, self).update_revisions(stop_revision,
1027
1010
overwrite, graph)
1012
@deprecated_method(deprecated_in((2, 4, 0)))
1029
1013
def import_last_revision_info(self, source_repo, revno, revid):
1030
1014
"""Set the last revision info, importing from another repo if necessary.
1032
This is used by the bound branch code to upload a revision to
1033
the master branch first before updating the tip of the local branch.
1035
1016
:param source_repo: Source repository to optionally fetch from
1036
1017
:param revno: Revision number of the new tip
1037
1018
:param revid: Revision id of the new tip
1040
1021
self.repository.fetch(source_repo, revision_id=revid)
1041
1022
self.set_last_revision_info(revno, revid)
1024
def import_last_revision_info_and_tags(self, source, revno, revid,
1026
"""Set the last revision info, importing from another repo if necessary.
1028
This is used by the bound branch code to upload a revision to
1029
the master branch first before updating the tip of the local branch.
1030
Revisions referenced by source's tags are also transferred.
1032
:param source: Source branch to optionally fetch from
1033
:param revno: Revision number of the new tip
1034
:param revid: Revision id of the new tip
1035
:param lossy: Whether to discard metadata that can not be
1036
natively represented
1037
:return: Tuple with the new revision number and revision id
1038
(should only be different from the arguments when lossy=True)
1040
if not self.repository.has_same_location(source.repository):
1041
self.fetch(source, revid)
1042
self.set_last_revision_info(revno, revid)
1043
return (revno, revid)
1043
1045
def revision_id_to_revno(self, revision_id):
1044
1046
"""Given a revision id, return its revno"""
1045
1047
if _mod_revision.is_null(revision_id):
1371
1374
"""Return the most suitable metadir for a checkout of this branch.
1372
1375
Weaves are used if this branch's repository uses weaves.
1374
if isinstance(self.bzrdir, bzrdir.BzrDirPreSplitOut):
1375
from bzrlib.repofmt import weaverepo
1376
format = bzrdir.BzrDirMetaFormat1()
1377
format.repository_format = weaverepo.RepositoryFormat7()
1379
format = self.repository.bzrdir.checkout_metadir()
1380
format.set_branch_format(self._format)
1377
format = self.repository.bzrdir.checkout_metadir()
1378
format.set_branch_format(self._format)
1383
1381
def create_clone_on_transport(self, to_transport, revision_id=None,
1524
1522
raise AssertionError("invalid heads: %r" % (heads,))
1527
class BranchFormat(object):
1524
def heads_to_fetch(self):
1525
"""Return the heads that must and that should be fetched to copy this
1526
branch into another repo.
1528
:returns: a 2-tuple of (must_fetch, if_present_fetch). must_fetch is a
1529
set of heads that must be fetched. if_present_fetch is a set of
1530
heads that must be fetched if present, but no error is necessary if
1531
they are not present.
1533
# For bzr native formats must_fetch is just the tip, and if_present_fetch
1535
must_fetch = set([self.last_revision()])
1537
if_present_fetch = set(self.tags.get_reverse_tag_dict())
1538
except errors.TagsNotSupported:
1539
if_present_fetch = set()
1540
must_fetch.discard(_mod_revision.NULL_REVISION)
1541
if_present_fetch.discard(_mod_revision.NULL_REVISION)
1542
return must_fetch, if_present_fetch
1545
class BranchFormat(controldir.ControlComponentFormat):
1528
1546
"""An encapsulation of the initialization and open routines for a format.
1530
1548
Formats provide three things:
1563
1575
transport = a_bzrdir.get_branch_transport(None, name=name)
1564
1576
format_string = transport.get_bytes("format")
1565
format = klass._formats[format_string]
1566
if isinstance(format, MetaDirBranchFormatFactory):
1577
return format_registry.get(format_string)
1569
1578
except errors.NoSuchFile:
1570
1579
raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1571
1580
except KeyError:
1572
1581
raise errors.UnknownFormatError(format=format_string, kind='branch')
1584
@deprecated_method(deprecated_in((2, 4, 0)))
1575
1585
def get_default_format(klass):
1576
1586
"""Return the current default format."""
1577
return klass._default_format
1587
return format_registry.get_default()
1590
@deprecated_method(deprecated_in((2, 4, 0)))
1580
1591
def get_formats(klass):
1581
1592
"""Get all the known formats.
1583
1594
Warning: This triggers a load of all lazy registered formats: do not
1584
1595
use except when that is desireed.
1587
for fmt in klass._formats.values():
1588
if isinstance(fmt, MetaDirBranchFormatFactory):
1597
return format_registry._get_all()
1593
1599
def get_reference(self, a_bzrdir, name=None):
1594
1600
"""Get the target reference of the branch in a_bzrdir.
1633
1639
for hook in hooks:
1636
def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
1637
lock_type='metadir', set_format=True):
1638
"""Initialize a branch in a bzrdir, with specified files
1640
:param a_bzrdir: The bzrdir to initialize the branch in
1641
:param utf8_files: The files to create as a list of
1642
(filename, content) tuples
1643
:param name: Name of colocated branch to create, if any
1644
:param set_format: If True, set the format with
1645
self.get_format_string. (BzrBranch4 has its format set
1647
:return: a branch in this format
1649
mutter('creating branch %r in %s', self, a_bzrdir.user_url)
1650
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1652
'metadir': ('lock', lockdir.LockDir),
1653
'branch4': ('branch-lock', lockable_files.TransportLock),
1655
lock_name, lock_class = lock_map[lock_type]
1656
control_files = lockable_files.LockableFiles(branch_transport,
1657
lock_name, lock_class)
1658
control_files.create_lock()
1660
control_files.lock_write()
1661
except errors.LockContention:
1662
if lock_type != 'branch4':
1668
utf8_files += [('format', self.get_format_string())]
1670
for (filename, content) in utf8_files:
1671
branch_transport.put_bytes(
1673
mode=a_bzrdir._get_file_mode())
1676
control_files.unlock()
1677
branch = self.open(a_bzrdir, name, _found=True)
1678
self._run_post_branch_init_hooks(a_bzrdir, name, branch)
1681
def initialize(self, a_bzrdir, name=None):
1642
def initialize(self, a_bzrdir, name=None, repository=None):
1682
1643
"""Create a branch of this format in a_bzrdir.
1684
1645
:param name: Name of the colocated branch to create.
1719
1680
raise NotImplementedError(self.network_name)
1721
def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
1682
def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False,
1683
found_repository=None):
1722
1684
"""Return the branch object for a_bzrdir
1724
1686
:param a_bzrdir: A BzrDir that contains a branch.
1731
1693
raise NotImplementedError(self.open)
1696
@deprecated_method(deprecated_in((2, 4, 0)))
1734
1697
def register_format(klass, format):
1735
1698
"""Register a metadir format.
1737
1700
See MetaDirBranchFormatFactory for the ability to register a format
1738
1701
without loading the code the format needs until it is actually used.
1740
klass._formats[format.get_format_string()] = format
1741
# Metadir formats have a network name of their format string, and get
1742
# registered as factories.
1743
if isinstance(format, MetaDirBranchFormatFactory):
1744
network_format_registry.register(format.get_format_string(), format)
1746
network_format_registry.register(format.get_format_string(),
1703
format_registry.register(format)
1706
@deprecated_method(deprecated_in((2, 4, 0)))
1750
1707
def set_default_format(klass, format):
1751
klass._default_format = format
1708
format_registry.set_default(format)
1753
1710
def supports_set_append_revisions_only(self):
1754
1711
"""True if this format supports set_append_revisions_only."""
1758
1715
"""True if this format records a stacked-on branch."""
1718
def supports_leaving_lock(self):
1719
"""True if this format supports leaving locks in place."""
1720
return False # by default
1723
@deprecated_method(deprecated_in((2, 4, 0)))
1762
1724
def unregister_format(klass, format):
1763
del klass._formats[format.get_format_string()]
1725
format_registry.remove(format)
1765
1727
def __str__(self):
1766
1728
return self.get_format_description().rstrip()
1811
1773
These are all empty initially, because by default nothing should get
1814
Hooks.__init__(self)
1815
self.create_hook(HookPoint('set_rh',
1776
Hooks.__init__(self, "bzrlib.branch", "Branch.hooks")
1777
self.add_hook('set_rh',
1816
1778
"Invoked whenever the revision history has been set via "
1817
1779
"set_revision_history. The api signature is (branch, "
1818
1780
"revision_history), and the branch will be write-locked. "
1819
1781
"The set_rh hook can be expensive for bzr to trigger, a better "
1820
"hook to use is Branch.post_change_branch_tip.", (0, 15), None))
1821
self.create_hook(HookPoint('open',
1782
"hook to use is Branch.post_change_branch_tip.", (0, 15))
1783
self.add_hook('open',
1822
1784
"Called with the Branch object that has been opened after a "
1823
"branch is opened.", (1, 8), None))
1824
self.create_hook(HookPoint('post_push',
1785
"branch is opened.", (1, 8))
1786
self.add_hook('post_push',
1825
1787
"Called after a push operation completes. post_push is called "
1826
1788
"with a bzrlib.branch.BranchPushResult object and only runs in the "
1827
"bzr client.", (0, 15), None))
1828
self.create_hook(HookPoint('post_pull',
1789
"bzr client.", (0, 15))
1790
self.add_hook('post_pull',
1829
1791
"Called after a pull operation completes. post_pull is called "
1830
1792
"with a bzrlib.branch.PullResult object and only runs in the "
1831
"bzr client.", (0, 15), None))
1832
self.create_hook(HookPoint('pre_commit',
1793
"bzr client.", (0, 15))
1794
self.add_hook('pre_commit',
1833
1795
"Called after a commit is calculated but before it is "
1834
1796
"completed. pre_commit is called with (local, master, old_revno, "
1835
1797
"old_revid, future_revno, future_revid, tree_delta, future_tree"
1838
1800
"basis revision. hooks MUST NOT modify this delta. "
1839
1801
" future_tree is an in-memory tree obtained from "
1840
1802
"CommitBuilder.revision_tree() and hooks MUST NOT modify this "
1841
"tree.", (0,91), None))
1842
self.create_hook(HookPoint('post_commit',
1804
self.add_hook('post_commit',
1843
1805
"Called in the bzr client after a commit has completed. "
1844
1806
"post_commit is called with (local, master, old_revno, old_revid, "
1845
1807
"new_revno, new_revid). old_revid is NULL_REVISION for the first "
1846
"commit to a branch.", (0, 15), None))
1847
self.create_hook(HookPoint('post_uncommit',
1808
"commit to a branch.", (0, 15))
1809
self.add_hook('post_uncommit',
1848
1810
"Called in the bzr client after an uncommit completes. "
1849
1811
"post_uncommit is called with (local, master, old_revno, "
1850
1812
"old_revid, new_revno, new_revid) where local is the local branch "
1851
1813
"or None, master is the target branch, and an empty branch "
1852
"receives new_revno of 0, new_revid of None.", (0, 15), None))
1853
self.create_hook(HookPoint('pre_change_branch_tip',
1814
"receives new_revno of 0, new_revid of None.", (0, 15))
1815
self.add_hook('pre_change_branch_tip',
1854
1816
"Called in bzr client and server before a change to the tip of a "
1855
1817
"branch is made. pre_change_branch_tip is called with a "
1856
1818
"bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1857
"commit, uncommit will all trigger this hook.", (1, 6), None))
1858
self.create_hook(HookPoint('post_change_branch_tip',
1819
"commit, uncommit will all trigger this hook.", (1, 6))
1820
self.add_hook('post_change_branch_tip',
1859
1821
"Called in bzr client and server after a change to the tip of a "
1860
1822
"branch is made. post_change_branch_tip is called with a "
1861
1823
"bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1862
"commit, uncommit will all trigger this hook.", (1, 4), None))
1863
self.create_hook(HookPoint('transform_fallback_location',
1824
"commit, uncommit will all trigger this hook.", (1, 4))
1825
self.add_hook('transform_fallback_location',
1864
1826
"Called when a stacked branch is activating its fallback "
1865
1827
"locations. transform_fallback_location is called with (branch, "
1866
1828
"url), and should return a new url. Returning the same url "
1871
1833
"fallback locations have not been activated. When there are "
1872
1834
"multiple hooks installed for transform_fallback_location, "
1873
1835
"all are called with the url returned from the previous hook."
1874
"The order is however undefined.", (1, 9), None))
1875
self.create_hook(HookPoint('automatic_tag_name',
1836
"The order is however undefined.", (1, 9))
1837
self.add_hook('automatic_tag_name',
1876
1838
"Called to determine an automatic tag name for a revision. "
1877
1839
"automatic_tag_name is called with (branch, revision_id) and "
1878
1840
"should return a tag name or None if no tag name could be "
1879
1841
"determined. The first non-None tag name returned will be used.",
1881
self.create_hook(HookPoint('post_branch_init',
1843
self.add_hook('post_branch_init',
1882
1844
"Called after new branch initialization completes. "
1883
1845
"post_branch_init is called with a "
1884
1846
"bzrlib.branch.BranchInitHookParams. "
1885
1847
"Note that init, branch and checkout (both heavyweight and "
1886
"lightweight) will all trigger this hook.", (2, 2), None))
1887
self.create_hook(HookPoint('post_switch',
1848
"lightweight) will all trigger this hook.", (2, 2))
1849
self.add_hook('post_switch',
1888
1850
"Called after a checkout switches branch. "
1889
1851
"post_switch is called with a "
1890
"bzrlib.branch.SwitchHookParams.", (2, 2), None))
1852
"bzrlib.branch.SwitchHookParams.", (2, 2))
2006
1968
self.revision_id)
2009
class BzrBranchFormat4(BranchFormat):
2010
"""Bzr branch format 4.
2013
- a revision-history file.
2014
- a branch-lock lock file [ to be shared with the bzrdir ]
2017
def get_format_description(self):
2018
"""See BranchFormat.get_format_description()."""
2019
return "Branch format 4"
2021
def initialize(self, a_bzrdir, name=None):
2022
"""Create a branch of this format in a_bzrdir."""
2023
utf8_files = [('revision-history', ''),
2024
('branch-name', ''),
2026
return self._initialize_helper(a_bzrdir, utf8_files, name=name,
2027
lock_type='branch4', set_format=False)
2030
super(BzrBranchFormat4, self).__init__()
2031
self._matchingbzrdir = bzrdir.BzrDirFormat6()
2033
def network_name(self):
2034
"""The network name for this format is the control dirs disk label."""
2035
return self._matchingbzrdir.get_format_string()
2037
def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
2038
"""See BranchFormat.open()."""
2040
# we are being called directly and must probe.
2041
raise NotImplementedError
2042
return BzrBranch(_format=self,
2043
_control_files=a_bzrdir._control_files,
2046
_repository=a_bzrdir.open_repository())
2049
return "Bazaar-NG branch format 4"
2052
1971
class BranchFormatMetadir(BranchFormat):
2053
1972
"""Common logic for meta-dir based branch formats."""
2056
1975
"""What class to instantiate on open calls."""
2057
1976
raise NotImplementedError(self._branch_class)
1978
def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
1980
"""Initialize a branch in a bzrdir, with specified files
1982
:param a_bzrdir: The bzrdir to initialize the branch in
1983
:param utf8_files: The files to create as a list of
1984
(filename, content) tuples
1985
:param name: Name of colocated branch to create, if any
1986
:return: a branch in this format
1988
mutter('creating branch %r in %s', self, a_bzrdir.user_url)
1989
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1990
control_files = lockable_files.LockableFiles(branch_transport,
1991
'lock', lockdir.LockDir)
1992
control_files.create_lock()
1993
control_files.lock_write()
1995
utf8_files += [('format', self.get_format_string())]
1996
for (filename, content) in utf8_files:
1997
branch_transport.put_bytes(
1999
mode=a_bzrdir._get_file_mode())
2001
control_files.unlock()
2002
branch = self.open(a_bzrdir, name, _found=True,
2003
found_repository=repository)
2004
self._run_post_branch_init_hooks(a_bzrdir, name, branch)
2059
2007
def network_name(self):
2060
2008
"""A simple byte string uniquely identifying this format for RPC calls.
2064
2012
return self.get_format_string()
2066
def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
2014
def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False,
2015
found_repository=None):
2067
2016
"""See BranchFormat.open()."""
2069
2018
format = BranchFormat.find_format(a_bzrdir, name=name)
2075
2024
control_files = lockable_files.LockableFiles(transport, 'lock',
2076
2025
lockdir.LockDir)
2026
if found_repository is None:
2027
found_repository = a_bzrdir.find_repository()
2077
2028
return self._branch_class()(_format=self,
2078
2029
_control_files=control_files,
2080
2031
a_bzrdir=a_bzrdir,
2081
_repository=a_bzrdir.find_repository(),
2032
_repository=found_repository,
2082
2033
ignore_fallbacks=ignore_fallbacks)
2083
2034
except errors.NoSuchFile:
2084
2035
raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
2116
2070
"""See BranchFormat.get_format_description()."""
2117
2071
return "Branch format 5"
2119
def initialize(self, a_bzrdir, name=None):
2073
def initialize(self, a_bzrdir, name=None, repository=None):
2120
2074
"""Create a branch of this format in a_bzrdir."""
2121
2075
utf8_files = [('revision-history', ''),
2122
2076
('branch-name', ''),
2124
return self._initialize_helper(a_bzrdir, utf8_files, name)
2078
return self._initialize_helper(a_bzrdir, utf8_files, name, repository)
2126
2080
def supports_tags(self):
2149
2103
"""See BranchFormat.get_format_description()."""
2150
2104
return "Branch format 6"
2152
def initialize(self, a_bzrdir, name=None):
2106
def initialize(self, a_bzrdir, name=None, repository=None):
2153
2107
"""Create a branch of this format in a_bzrdir."""
2154
2108
utf8_files = [('last-revision', '0 null:\n'),
2155
2109
('branch.conf', ''),
2158
return self._initialize_helper(a_bzrdir, utf8_files, name)
2112
return self._initialize_helper(a_bzrdir, utf8_files, name, repository)
2160
2114
def make_tags(self, branch):
2161
2115
"""See bzrlib.branch.BranchFormat.make_tags()."""
2179
2133
"""See BranchFormat.get_format_description()."""
2180
2134
return "Branch format 8"
2182
def initialize(self, a_bzrdir, name=None):
2136
def initialize(self, a_bzrdir, name=None, repository=None):
2183
2137
"""Create a branch of this format in a_bzrdir."""
2184
2138
utf8_files = [('last-revision', '0 null:\n'),
2185
2139
('branch.conf', ''),
2187
2141
('references', '')
2189
return self._initialize_helper(a_bzrdir, utf8_files, name)
2192
super(BzrBranchFormat8, self).__init__()
2193
self._matchingbzrdir.repository_format = \
2194
RepositoryFormatKnitPack5RichRoot()
2143
return self._initialize_helper(a_bzrdir, utf8_files, name, repository)
2196
2145
def make_tags(self, branch):
2197
2146
"""See bzrlib.branch.BranchFormat.make_tags()."""
2215
2164
This format was introduced in bzr 1.6.
2218
def initialize(self, a_bzrdir, name=None):
2167
def initialize(self, a_bzrdir, name=None, repository=None):
2219
2168
"""Create a branch of this format in a_bzrdir."""
2220
2169
utf8_files = [('last-revision', '0 null:\n'),
2221
2170
('branch.conf', ''),
2224
return self._initialize_helper(a_bzrdir, utf8_files, name)
2173
return self._initialize_helper(a_bzrdir, utf8_files, name, repository)
2226
2175
def _branch_class(self):
2227
2176
return BzrBranch7
2269
2225
transport = a_bzrdir.get_branch_transport(None, name=name)
2270
2226
location = transport.put_bytes('location', to_branch.base)
2272
def initialize(self, a_bzrdir, name=None, target_branch=None):
2228
def initialize(self, a_bzrdir, name=None, target_branch=None,
2273
2230
"""Create a branch of this format in a_bzrdir."""
2274
2231
if target_branch is None:
2275
2232
# this format does not implement branch itself, thus the implicit
2301
class BranchFormatRegistry(controldir.ControlComponentFormatRegistry):
2302
"""Branch format registry."""
2304
def __init__(self, other_registry=None):
2305
super(BranchFormatRegistry, self).__init__(other_registry)
2306
self._default_format = None
2308
def set_default(self, format):
2309
self._default_format = format
2311
def get_default(self):
2312
return self._default_format
2343
2315
network_format_registry = registry.FormatRegistry()
2344
2316
"""Registry of formats indexed by their network name.
2355
2329
__format6 = BzrBranchFormat6()
2356
2330
__format7 = BzrBranchFormat7()
2357
2331
__format8 = BzrBranchFormat8()
2358
BranchFormat.register_format(__format5)
2359
BranchFormat.register_format(BranchReferenceFormat())
2360
BranchFormat.register_format(__format6)
2361
BranchFormat.register_format(__format7)
2362
BranchFormat.register_format(__format8)
2363
BranchFormat.set_default_format(__format7)
2364
_legacy_formats = [BzrBranchFormat4(),
2366
network_format_registry.register(
2367
_legacy_formats[0].network_name(), _legacy_formats[0].__class__)
2332
format_registry.register(__format5)
2333
format_registry.register(BranchReferenceFormat())
2334
format_registry.register(__format6)
2335
format_registry.register(__format7)
2336
format_registry.register(__format8)
2337
format_registry.set_default(__format7)
2370
2340
class BranchWriteLockResult(LogicalLockResult):
2527
2497
'revision-history', '\n'.join(history),
2528
2498
mode=self.bzrdir._get_file_mode())
2500
@deprecated_method(deprecated_in((2, 4, 0)))
2531
2501
def set_revision_history(self, rev_history):
2532
2502
"""See Branch.set_revision_history."""
2503
self._set_revision_history(rev_history)
2506
def _set_revision_history(self, rev_history):
2533
2507
if 'evil' in debug.debug_flags:
2534
2508
mutter_callsite(3, "set_revision_history scales with history.")
2535
2509
check_not_reserved_id = _mod_revision.check_not_reserved_id
2593
2567
configured to check constraints on history, in which case this may not
2596
revision_id = _mod_revision.ensure_null(revision_id)
2570
if not revision_id or not isinstance(revision_id, basestring):
2571
raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2597
2572
# this old format stores the full history, but this api doesn't
2598
2573
# provide it, so we must generate, and might as well check it's
2600
2575
history = self._lefthand_history(revision_id)
2601
2576
if len(history) != revno:
2602
2577
raise AssertionError('%d != %d' % (len(history), revno))
2603
self.set_revision_history(history)
2578
self._set_revision_history(history)
2605
2580
def _gen_revision_history(self):
2606
2581
history = self._transport.get_bytes('revision-history').split('\n')
2646
2621
result.target_branch = target
2647
2622
result.old_revno, result.old_revid = target.last_revision_info()
2648
2623
self.update_references(target)
2649
if result.old_revid != self.last_revision():
2624
if result.old_revid != stop_revision:
2650
2625
# We assume that during 'push' this repository is closer than
2652
2627
graph = self.repository.get_graph(target.repository)
2653
2628
target.update_revisions(self, stop_revision,
2654
2629
overwrite=overwrite, graph=graph)
2655
2630
if self._push_should_merge_tags():
2656
result.tag_conflicts = self.tags.merge_to(target.tags,
2631
result.tag_conflicts = self.tags.merge_to(target.tags, overwrite)
2658
2632
result.new_revno, result.new_revid = target.last_revision_info()
2692
2666
"""Return the branch we are bound to.
2694
2668
:return: Either a Branch, or None
2696
This could memoise the branch, but if thats done
2697
it must be revalidated on each new lock.
2698
So for now we just don't memoise it.
2699
# RBC 20060304 review this decision.
2670
if self._master_branch_cache is None:
2671
self._master_branch_cache = self._get_master_branch(
2672
possible_transports)
2673
return self._master_branch_cache
2675
def _get_master_branch(self, possible_transports):
2701
2676
bound_loc = self.get_bound_location()
2702
2677
if not bound_loc:
2829
2805
@needs_write_lock
2830
2806
def set_last_revision_info(self, revno, revision_id):
2831
revision_id = _mod_revision.ensure_null(revision_id)
2807
if not revision_id or not isinstance(revision_id, basestring):
2808
raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2832
2809
old_revno, old_revid = self.last_revision_info()
2833
2810
if self._get_append_revisions_only():
2834
2811
self._check_history_violation(revision_id)
3054
3032
index = self._partial_revision_history_cache.index(revision_id)
3055
3033
except ValueError:
3056
self._extend_partial_history(stop_revision=revision_id)
3035
self._extend_partial_history(stop_revision=revision_id)
3036
except errors.RevisionNotPresent, e:
3037
raise errors.GhostRevisionsHaveNoRevno(revision_id, e.revision_id)
3057
3038
index = len(self._partial_revision_history_cache) - 1
3058
3039
if self._partial_revision_history_cache[index] != revision_id:
3059
3040
raise errors.NoSuchRevision(self, revision_id)
3377
3366
self.source.tags.merge_to(self.target.tags)
3379
3368
@needs_write_lock
3369
def fetch(self, stop_revision=None):
3370
if self.target.base == self.source.base:
3372
self.source.lock_read()
3374
fetch_spec_factory = fetch.FetchSpecFactory()
3375
fetch_spec_factory.source_branch = self.source
3376
fetch_spec_factory.source_branch_stop_revision_id = stop_revision
3377
fetch_spec_factory.source_repo = self.source.repository
3378
fetch_spec_factory.target_repo = self.target.repository
3379
fetch_spec_factory.target_repo_kind = fetch.TargetRepoKinds.PREEXISTING
3380
fetch_spec = fetch_spec_factory.make_fetch_spec()
3381
return self.target.repository.fetch(self.source.repository,
3382
fetch_spec=fetch_spec)
3384
self.source.unlock()
3380
3387
def update_revisions(self, stop_revision=None, overwrite=False,
3382
3389
"""See InterBranch.update_revisions()."""
3383
3390
other_revno, other_last_revision = self.source.last_revision_info()
3384
3391
stop_revno = None # unknown
3516
3525
def _pull(self, overwrite=False, stop_revision=None,
3517
3526
possible_transports=None, _hook_master=None, run_hooks=True,
3518
_override_hook_target=None, local=False):
3527
_override_hook_target=None, local=False,
3528
merge_tags_to_master=True):
3519
3529
"""See Branch.pull.
3521
3531
This function is the core worker, used by GenericInterBranch.pull to
3526
3536
:param run_hooks: Private parameter - if false, this branch
3527
3537
is being called because it's the master of the primary branch,
3528
3538
so it should not run its hooks.
3539
is being called because it's the master of the primary branch,
3540
so it should not run its hooks.
3529
3541
:param _override_hook_target: Private parameter - set the branch to be
3530
3542
supplied as the target_branch to pull hooks.
3531
3543
:param local: Only update the local branch, and not the bound branch.
added
removed
bzrlib/branch.py
