14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
from __future__ import absolute_import
18
21
from cStringIO import StringIO
21
23
from bzrlib.lazy_import import lazy_import
22
24
lazy_import(globals(), """
23
from itertools import chain
24
26
from bzrlib import (
28
config as _mod_config,
37
revision as _mod_revision,
43
from bzrlib.config import BranchConfig, TransportConfig
44
from bzrlib.tag import (
31
config as _mod_config,
40
revision as _mod_revision,
48
from bzrlib.i18n import gettext, ngettext
51
# Explicitly import bzrlib.bzrdir so that the BzrProber
52
# is guaranteed to be registered.
50
55
from bzrlib import (
53
59
from bzrlib.decorators import (
88
94
def user_transport(self):
89
95
return self.bzrdir.user_transport
91
def __init__(self, *ignored, **ignored_too):
97
def __init__(self, possible_transports=None):
92
98
self.tags = self._format.make_tags(self)
93
99
self._revision_history_cache = None
94
100
self._revision_id_to_revno_cache = None
98
104
self._last_revision_info_cache = None
99
105
self._master_branch_cache = None
100
106
self._merge_sorted_revisions_cache = None
107
self._open_hook(possible_transports)
102
108
hooks = Branch.hooks['open']
103
109
for hook in hooks:
106
def _open_hook(self):
112
def _open_hook(self, possible_transports):
107
113
"""Called by init to allow simpler extension of the base class."""
109
def _activate_fallback_location(self, url):
115
def _activate_fallback_location(self, url, possible_transports):
110
116
"""Activate the branch/repository from url as a fallback repository."""
111
117
for existing_fallback_repo in self.repository._fallback_repositories:
112
118
if existing_fallback_repo.user_url == url:
113
119
# This fallback is already configured. This probably only
114
# happens because BzrDir.sprout is a horrible mess. To avoid
120
# happens because ControlDir.sprout is a horrible mess. To avoid
115
121
# confusing _unstack we don't add this a second time.
116
122
mutter('duplicate activation of fallback %r on %r', url, self)
118
repo = self._get_fallback_repository(url)
124
repo = self._get_fallback_repository(url, possible_transports)
119
125
if repo.has_same_location(self.repository):
120
126
raise errors.UnstackableLocationError(self.user_url, url)
121
127
self.repository.add_fallback_repository(repo)
175
181
For instance, if the branch is at URL/.bzr/branch,
176
182
Branch.open(URL) -> a Branch instance.
178
control = bzrdir.BzrDir.open(base, _unsupported,
179
possible_transports=possible_transports)
180
return control.open_branch(unsupported=_unsupported)
184
control = controldir.ControlDir.open(base,
185
possible_transports=possible_transports, _unsupported=_unsupported)
186
return control.open_branch(unsupported=_unsupported,
187
possible_transports=possible_transports)
183
def open_from_transport(transport, name=None, _unsupported=False):
190
def open_from_transport(transport, name=None, _unsupported=False,
191
possible_transports=None):
184
192
"""Open the branch rooted at transport"""
185
control = bzrdir.BzrDir.open_from_transport(transport, _unsupported)
186
return control.open_branch(name=name, unsupported=_unsupported)
193
control = controldir.ControlDir.open_from_transport(transport, _unsupported)
194
return control.open_branch(name=name, unsupported=_unsupported,
195
possible_transports=possible_transports)
189
198
def open_containing(url, possible_transports=None):
197
206
format, UnknownFormatError or UnsupportedFormatError are raised.
198
207
If there is one, it is returned, along with the unused portion of url.
200
control, relpath = bzrdir.BzrDir.open_containing(url,
209
control, relpath = controldir.ControlDir.open_containing(url,
201
210
possible_transports)
202
return control.open_branch(), relpath
211
branch = control.open_branch(possible_transports=possible_transports)
212
return (branch, relpath)
204
214
def _push_should_merge_tags(self):
205
215
"""Should _basic_push merge this branch's tags into the target?
218
228
:return: A bzrlib.config.BranchConfig.
220
return BranchConfig(self)
230
return _mod_config.BranchConfig(self)
232
def get_config_stack(self):
233
"""Get a bzrlib.config.BranchStack for this Branch.
235
This can then be used to get and set configuration options for the
238
:return: A bzrlib.config.BranchStack.
240
return _mod_config.BranchStack(self)
222
242
def _get_config(self):
223
243
"""Get the concrete config for just the config in this branch.
232
252
raise NotImplementedError(self._get_config)
234
def _get_fallback_repository(self, url):
254
def _get_fallback_repository(self, url, possible_transports):
235
255
"""Get the repository we fallback to at url."""
236
256
url = urlutils.join(self.base, url)
237
a_branch = Branch.open(url,
238
possible_transports=[self.bzrdir.root_transport])
257
a_branch = Branch.open(url, possible_transports=possible_transports)
239
258
return a_branch.repository
647
666
raise errors.UpgradeRequired(self.user_url)
668
def get_append_revisions_only(self):
669
"""Whether it is only possible to append revisions to the history.
671
if not self._format.supports_set_append_revisions_only():
673
return self.get_config_stack().get('append_revisions_only')
649
675
def set_append_revisions_only(self, enabled):
650
676
if not self._format.supports_set_append_revisions_only():
651
677
raise errors.UpgradeRequired(self.user_url)
656
self.get_config().set_user_option('append_revisions_only', value,
678
self.get_config_stack().set('append_revisions_only', enabled)
659
680
def set_reference_info(self, file_id, tree_path, branch_location):
660
681
"""Set the branch location to use for a tree reference."""
690
711
raise errors.UpgradeRequired(self.user_url)
692
def get_commit_builder(self, parents, config=None, timestamp=None,
713
def get_commit_builder(self, parents, config_stack=None, timestamp=None,
693
714
timezone=None, committer=None, revprops=None,
694
715
revision_id=None, lossy=False):
695
716
"""Obtain a CommitBuilder for this branch.
705
726
represented, when pushing to a foreign VCS
709
config = self.get_config()
729
if config_stack is None:
730
config_stack = self.get_config_stack()
711
return self.repository.get_commit_builder(self, parents, config,
732
return self.repository.get_commit_builder(self, parents, config_stack,
712
733
timestamp, timezone, committer, revprops, revision_id,
743
@deprecated_method(deprecated_in((2, 5, 0)))
722
744
def get_revision_delta(self, revno):
723
745
"""Return the delta for one revision.
725
747
The delta is relative to its mainline predecessor, or the
726
748
empty tree for revision 1.
728
rh = self.revision_history()
729
if not (1 <= revno <= len(rh)):
751
revid = self.get_rev_id(revno)
752
except errors.NoSuchRevision:
730
753
raise errors.InvalidRevisionNumber(revno)
731
return self.repository.get_revision_delta(rh[revno-1])
754
return self.repository.get_revision_delta(revid)
733
756
def get_stacked_on_url(self):
734
757
"""Get the URL this branch is stacked against.
865
889
# stream from one of them to the other. This does mean doing
866
890
# separate SSH connection setup, but unstacking is not a
867
891
# common operation so it's tolerable.
868
new_bzrdir = bzrdir.BzrDir.open(self.bzrdir.root_transport.base)
892
new_bzrdir = controldir.ControlDir.open(
893
self.bzrdir.root_transport.base)
869
894
new_repository = new_bzrdir.find_repository()
870
895
if new_repository._fallback_repositories:
871
896
raise AssertionError("didn't expect %r to have "
914
939
tags_to_fetch = set(self.tags.get_reverse_tag_dict())
915
940
except errors.TagsNotSupported:
916
941
tags_to_fetch = set()
917
fetch_spec = _mod_graph.NotInOtherForRevs(self.repository,
942
fetch_spec = vf_search.NotInOtherForRevs(self.repository,
918
943
old_repository, required_ids=[self.last_revision()],
919
944
if_present_ids=tags_to_fetch, find_ghosts=True).execute()
920
945
self.repository.fetch(old_repository, fetch_spec=fetch_spec)
1141
1170
def _set_config_location(self, name, url, config=None,
1142
1171
make_relative=False):
1143
1172
if config is None:
1144
config = self.get_config()
1173
config = self.get_config_stack()
1145
1174
if url is None:
1147
1176
elif make_relative:
1148
1177
url = urlutils.relative_url(self.base, url)
1149
config.set_user_option(name, url, warn_masked=True)
1178
config.set(name, url)
1151
1180
def _get_config_location(self, name, config=None):
1152
1181
if config is None:
1153
config = self.get_config()
1154
location = config.get_user_option(name)
1182
config = self.get_config_stack()
1183
location = config.get(name)
1155
1184
if location == '':
1156
1185
location = None
1157
1186
return location
1159
1188
def get_child_submit_format(self):
1160
1189
"""Return the preferred format of submissions to this branch."""
1161
return self.get_config().get_user_option("child_submit_format")
1190
return self.get_config_stack().get('child_submit_format')
1163
1192
def get_submit_branch(self):
1164
1193
"""Return the submit location of the branch.
1196
1224
self._set_config_location('public_branch', location)
1198
1226
def get_push_location(self):
1199
"""Return the None or the location to push this branch to."""
1200
push_loc = self.get_config().get_user_option('push_location')
1227
"""Return None or the location to push this branch to."""
1228
return self.get_config_stack().get('push_location')
1203
1230
def set_push_location(self, location):
1204
1231
"""Set a new push location for this branch."""
1373
1400
# TODO: We should probably also check that self.revision_history
1374
1401
# matches the repository for older branch formats.
1375
1402
# If looking for the code that cross-checks repository parents against
1376
# the iter_reverse_revision_history output, that is now a repository
1403
# the Graph.iter_lefthand_ancestry output, that is now a repository
1377
1404
# specific check.
1380
def _get_checkout_format(self):
1407
def _get_checkout_format(self, lightweight=False):
1381
1408
"""Return the most suitable metadir for a checkout of this branch.
1382
1409
Weaves are used if this branch's repository uses weaves.
1430
1457
t = transport.get_transport(to_location)
1431
1458
t.ensure_base()
1459
format = self._get_checkout_format(lightweight=lightweight)
1461
checkout = format.initialize_on_transport(t)
1462
except errors.AlreadyControlDirError:
1463
# It's fine if the control directory already exists,
1464
# as long as there is no existing branch and working tree.
1465
checkout = controldir.ControlDir.open_from_transport(t)
1467
checkout.open_branch()
1468
except errors.NotBranchError:
1471
raise errors.AlreadyControlDirError(t.base)
1472
if checkout.control_transport.base == self.bzrdir.control_transport.base:
1473
# When checking out to the same control directory,
1474
# always create a lightweight checkout
1432
1477
if lightweight:
1433
format = self._get_checkout_format()
1434
checkout = format.initialize_on_transport(t)
1435
from_branch = BranchReferenceFormat().initialize(checkout,
1478
from_branch = checkout.set_branch_reference(target_branch=self)
1438
format = self._get_checkout_format()
1439
checkout_branch = bzrdir.BzrDir.create_branch_convenience(
1440
to_location, force_new_tree=False, format=format)
1441
checkout = checkout_branch.bzrdir
1480
policy = checkout.determine_repository_policy()
1481
repo = policy.acquire_repository()[0]
1482
checkout_branch = checkout.create_branch()
1442
1483
checkout_branch.bind(self)
1443
1484
# pull up to the specified revision_id to set the initial
1444
1485
# branch tip correctly, and seed it with history.
1445
1486
checkout_branch.pull(self, stop_revision=revision_id)
1447
1488
tree = checkout.create_workingtree(revision_id,
1448
1489
from_branch=from_branch,
1449
1490
accelerator_tree=accelerator_tree,
1538
1579
heads that must be fetched if present, but no error is necessary if
1539
1580
they are not present.
1541
# For bzr native formats must_fetch is just the tip, and if_present_fetch
1582
# For bzr native formats must_fetch is just the tip, and
1583
# if_present_fetch are the tags.
1543
1584
must_fetch = set([self.last_revision()])
1544
1585
if_present_fetch = set()
1545
c = self.get_config()
1546
include_tags = c.get_user_option_as_bool('branch.fetch_tags',
1586
if self.get_config_stack().get('branch.fetch_tags'):
1550
1588
if_present_fetch = set(self.tags.get_reverse_tag_dict())
1551
1589
except errors.TagsNotSupported:
1582
1618
return not (self == other)
1585
def find_format(klass, a_bzrdir, name=None):
1586
"""Return the format for the branch object in a_bzrdir."""
1588
transport = a_bzrdir.get_branch_transport(None, name=name)
1589
format_string = transport.get_bytes("format")
1590
return format_registry.get(format_string)
1591
except errors.NoSuchFile:
1592
raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1594
raise errors.UnknownFormatError(format=format_string, kind='branch')
1597
1621
@deprecated_method(deprecated_in((2, 4, 0)))
1598
1622
def get_default_format(klass):
1599
1623
"""Return the current default format."""
1610
1634
return format_registry._get_all()
1612
def get_reference(self, a_bzrdir, name=None):
1613
"""Get the target reference of the branch in a_bzrdir.
1636
def get_reference(self, controldir, name=None):
1637
"""Get the target reference of the branch in controldir.
1615
1639
format probing must have been completed before calling
1616
1640
this method - it is assumed that the format of the branch
1617
in a_bzrdir is correct.
1641
in controldir is correct.
1619
:param a_bzrdir: The bzrdir to get the branch data from.
1643
:param controldir: The controldir to get the branch data from.
1620
1644
:param name: Name of the colocated branch to fetch
1621
1645
:return: None if the branch is not a reference branch.
1626
def set_reference(self, a_bzrdir, name, to_branch):
1627
"""Set the target reference of the branch in a_bzrdir.
1650
def set_reference(self, controldir, name, to_branch):
1651
"""Set the target reference of the branch in controldir.
1629
1653
format probing must have been completed before calling
1630
1654
this method - it is assumed that the format of the branch
1631
in a_bzrdir is correct.
1655
in controldir is correct.
1633
:param a_bzrdir: The bzrdir to set the branch reference for.
1657
:param controldir: The controldir to set the branch reference for.
1634
1658
:param name: Name of colocated branch to set, None for default
1635
1659
:param to_branch: branch that the checkout is to reference
1637
1661
raise NotImplementedError(self.set_reference)
1639
def get_format_string(self):
1640
"""Return the ASCII format string that identifies this format."""
1641
raise NotImplementedError(self.get_format_string)
1643
1663
def get_format_description(self):
1644
1664
"""Return the short format description for this format."""
1645
1665
raise NotImplementedError(self.get_format_description)
1647
def _run_post_branch_init_hooks(self, a_bzrdir, name, branch):
1667
def _run_post_branch_init_hooks(self, controldir, name, branch):
1648
1668
hooks = Branch.hooks['post_branch_init']
1651
params = BranchInitHookParams(self, a_bzrdir, name, branch)
1671
params = BranchInitHookParams(self, controldir, name, branch)
1652
1672
for hook in hooks:
1655
def initialize(self, a_bzrdir, name=None, repository=None):
1656
"""Create a branch of this format in a_bzrdir.
1675
def initialize(self, controldir, name=None, repository=None,
1676
append_revisions_only=None):
1677
"""Create a branch of this format in controldir.
1658
1679
:param name: Name of the colocated branch to create.
1660
1681
raise NotImplementedError(self.initialize)
1693
1714
raise NotImplementedError(self.network_name)
1695
def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False,
1696
found_repository=None):
1697
"""Return the branch object for a_bzrdir
1716
def open(self, controldir, name=None, _found=False, ignore_fallbacks=False,
1717
found_repository=None, possible_transports=None):
1718
"""Return the branch object for controldir.
1699
:param a_bzrdir: A BzrDir that contains a branch.
1720
:param controldir: A ControlDir that contains a branch.
1700
1721
:param name: Name of colocated branch to open
1701
1722
:param _found: a private parameter, do not use it. It is used to
1702
1723
indicate if format probing has already be done.
1744
1765
"""True if this format supports tags stored in the branch"""
1745
1766
return False # by default
1768
def tags_are_versioned(self):
1769
"""Whether the tag container for this branch versions tags."""
1772
def supports_tags_referencing_ghosts(self):
1773
"""True if tags can reference ghost revisions."""
1748
1777
class MetaDirBranchFormatFactory(registry._LazyObjectGetter):
1749
1778
"""A factory for a BranchFormat object, permitting simple lazy registration.
1923
1952
branch, which refer to the original branch.
1926
def __init__(self, format, a_bzrdir, name, branch):
1955
def __init__(self, format, controldir, name, branch):
1927
1956
"""Create a group of BranchInitHook parameters.
1929
1958
:param format: the branch format
1930
:param a_bzrdir: the BzrDir where the branch will be/has been
1959
:param controldir: the ControlDir where the branch will be/has been
1932
1961
:param name: name of colocated branch, if any (or None)
1933
1962
:param branch: the branch created
1962
1991
def __init__(self, control_dir, to_branch, force, revision_id):
1963
1992
"""Create a group of SwitchHook parameters.
1965
:param control_dir: BzrDir of the checkout to change
1994
:param control_dir: ControlDir of the checkout to change
1966
1995
:param to_branch: branch that the checkout is to reference
1967
1996
:param force: skip the check for local commits in a heavy checkout
1968
1997
:param revision_id: revision ID to switch to (or None)
1981
2010
self.revision_id)
1984
class BranchFormatMetadir(BranchFormat):
1985
"""Common logic for meta-dir based branch formats."""
2013
class BranchFormatMetadir(bzrdir.BzrFormat, BranchFormat):
2014
"""Base class for branch formats that live in meta directories.
2018
BranchFormat.__init__(self)
2019
bzrdir.BzrFormat.__init__(self)
2022
def find_format(klass, controldir, name=None):
2023
"""Return the format for the branch object in controldir."""
2025
transport = controldir.get_branch_transport(None, name=name)
2026
except errors.NoSuchFile:
2027
raise errors.NotBranchError(path=name, bzrdir=controldir)
2029
format_string = transport.get_bytes("format")
2030
except errors.NoSuchFile:
2031
raise errors.NotBranchError(path=transport.base, bzrdir=controldir)
2032
return klass._find_format(format_registry, 'branch', format_string)
1987
2034
def _branch_class(self):
1988
2035
"""What class to instantiate on open calls."""
1989
2036
raise NotImplementedError(self._branch_class)
2038
def _get_initial_config(self, append_revisions_only=None):
2039
if append_revisions_only:
2040
return "append_revisions_only = True\n"
2042
# Avoid writing anything if append_revisions_only is disabled,
2043
# as that is the default.
1991
2046
def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
1992
2047
repository=None):
1993
2048
"""Initialize a branch in a bzrdir, with specified files
1998
2053
:param name: Name of colocated branch to create, if any
1999
2054
:return: a branch in this format
2057
name = a_bzrdir._get_selected_branch()
2001
2058
mutter('creating branch %r in %s', self, a_bzrdir.user_url)
2002
2059
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
2003
2060
control_files = lockable_files.LockableFiles(branch_transport,
2017
2074
self._run_post_branch_init_hooks(a_bzrdir, name, branch)
2020
def network_name(self):
2021
"""A simple byte string uniquely identifying this format for RPC calls.
2023
Metadir branch formats use their format string.
2025
return self.get_format_string()
2027
2077
def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False,
2028
found_repository=None):
2078
found_repository=None, possible_transports=None):
2029
2079
"""See BranchFormat.open()."""
2081
name = a_bzrdir._get_selected_branch()
2031
format = BranchFormat.find_format(a_bzrdir, name=name)
2083
format = BranchFormatMetadir.find_format(a_bzrdir, name=name)
2032
2084
if format.__class__ != self.__class__:
2033
2085
raise AssertionError("wrong format %r found for %r" %
2034
2086
(format, self))
2044
2096
a_bzrdir=a_bzrdir,
2045
2097
_repository=found_repository,
2046
ignore_fallbacks=ignore_fallbacks)
2098
ignore_fallbacks=ignore_fallbacks,
2099
possible_transports=possible_transports)
2047
2100
except errors.NoSuchFile:
2048
2101
raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
2051
super(BranchFormatMetadir, self).__init__()
2052
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
2053
self._matchingbzrdir.set_branch_format(self)
2104
def _matchingbzrdir(self):
2105
ret = bzrdir.BzrDirMetaFormat1()
2106
ret.set_branch_format(self)
2055
2109
def supports_tags(self):
2058
2112
def supports_leaving_lock(self):
2115
def check_support_status(self, allow_unsupported, recommend_upgrade=True,
2117
BranchFormat.check_support_status(self,
2118
allow_unsupported=allow_unsupported, recommend_upgrade=recommend_upgrade,
2120
bzrdir.BzrFormat.check_support_status(self, allow_unsupported=allow_unsupported,
2121
recommend_upgrade=recommend_upgrade, basedir=basedir)
2062
2124
class BzrBranchFormat5(BranchFormatMetadir):
2063
2125
"""Bzr branch format 5.
2083
2146
"""See BranchFormat.get_format_description()."""
2084
2147
return "Branch format 5"
2086
def initialize(self, a_bzrdir, name=None, repository=None):
2149
def initialize(self, a_bzrdir, name=None, repository=None,
2150
append_revisions_only=None):
2087
2151
"""Create a branch of this format in a_bzrdir."""
2152
if append_revisions_only:
2153
raise errors.UpgradeRequired(a_bzrdir.user_url)
2088
2154
utf8_files = [('revision-history', ''),
2089
2155
('branch-name', ''),
2116
2183
"""See BranchFormat.get_format_description()."""
2117
2184
return "Branch format 6"
2119
def initialize(self, a_bzrdir, name=None, repository=None):
2186
def initialize(self, a_bzrdir, name=None, repository=None,
2187
append_revisions_only=None):
2120
2188
"""Create a branch of this format in a_bzrdir."""
2121
2189
utf8_files = [('last-revision', '0 null:\n'),
2122
('branch.conf', ''),
2191
self._get_initial_config(append_revisions_only)),
2125
2194
return self._initialize_helper(a_bzrdir, utf8_files, name, repository)
2127
2196
def make_tags(self, branch):
2128
2197
"""See bzrlib.branch.BranchFormat.make_tags()."""
2129
return BasicTags(branch)
2198
return _mod_tag.BasicTags(branch)
2131
2200
def supports_set_append_revisions_only(self):
2146
2216
"""See BranchFormat.get_format_description()."""
2147
2217
return "Branch format 8"
2149
def initialize(self, a_bzrdir, name=None, repository=None):
2219
def initialize(self, a_bzrdir, name=None, repository=None,
2220
append_revisions_only=None):
2150
2221
"""Create a branch of this format in a_bzrdir."""
2151
2222
utf8_files = [('last-revision', '0 null:\n'),
2152
('branch.conf', ''),
2224
self._get_initial_config(append_revisions_only)),
2154
2226
('references', '')
2177
2249
This format was introduced in bzr 1.6.
2180
def initialize(self, a_bzrdir, name=None, repository=None):
2252
def initialize(self, a_bzrdir, name=None, repository=None,
2253
append_revisions_only=None):
2181
2254
"""Create a branch of this format in a_bzrdir."""
2182
2255
utf8_files = [('last-revision', '0 null:\n'),
2183
('branch.conf', ''),
2257
self._get_initial_config(append_revisions_only)),
2186
2260
return self._initialize_helper(a_bzrdir, utf8_files, name, repository)
2205
2280
def make_tags(self, branch):
2206
2281
"""See bzrlib.branch.BranchFormat.make_tags()."""
2207
return BasicTags(branch)
2282
return _mod_tag.BasicTags(branch)
2209
2284
supports_reference_locations = False
2212
class BranchReferenceFormat(BranchFormat):
2287
class BranchReferenceFormat(BranchFormatMetadir):
2213
2288
"""Bzr branch reference format.
2215
2290
Branch references are used in implementing checkouts, they
2239
2315
location = transport.put_bytes('location', to_branch.base)
2241
2317
def initialize(self, a_bzrdir, name=None, target_branch=None,
2318
repository=None, append_revisions_only=None):
2243
2319
"""Create a branch of this format in a_bzrdir."""
2244
2320
if target_branch is None:
2245
2321
# this format does not implement branch itself, thus the implicit
2246
2322
# creation contract must see it as uninitializable
2247
2323
raise errors.UninitializableFormat(self)
2248
2324
mutter('creating branch reference in %s', a_bzrdir.user_url)
2325
if a_bzrdir._format.fixed_components:
2326
raise errors.IncompatibleFormat(self, a_bzrdir._format)
2328
name = a_bzrdir._get_selected_branch()
2249
2329
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
2250
2330
branch_transport.put_bytes('location',
2251
target_branch.bzrdir.user_url)
2252
branch_transport.put_bytes('format', self.get_format_string())
2254
a_bzrdir, name, _found=True,
2331
target_branch.user_url)
2332
branch_transport.put_bytes('format', self.as_string())
2333
branch = self.open(a_bzrdir, name, _found=True,
2255
2334
possible_transports=[target_branch.bzrdir.root_transport])
2256
2335
self._run_post_branch_init_hooks(a_bzrdir, name, branch)
2260
super(BranchReferenceFormat, self).__init__()
2261
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
2262
self._matchingbzrdir.set_branch_format(self)
2264
2338
def _make_reference_clone_function(format, a_branch):
2265
2339
"""Create a clone() routine for a branch dynamically."""
2266
2340
def clone(to_bzrdir, revision_id=None,
2289
2363
:param possible_transports: An optional reusable transports list.
2366
name = a_bzrdir._get_selected_branch()
2292
format = BranchFormat.find_format(a_bzrdir, name=name)
2368
format = BranchFormatMetadir.find_format(a_bzrdir, name=name)
2293
2369
if format.__class__ != self.__class__:
2294
2370
raise AssertionError("wrong format %r found for %r" %
2295
2371
(format, self))
2296
2372
if location is None:
2297
2373
location = self.get_reference(a_bzrdir, name)
2298
real_bzrdir = bzrdir.BzrDir.open(
2374
real_bzrdir = controldir.ControlDir.open(
2299
2375
location, possible_transports=possible_transports)
2300
result = real_bzrdir.open_branch(name=name,
2301
ignore_fallbacks=ignore_fallbacks)
2376
result = real_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks,
2377
possible_transports=possible_transports)
2302
2378
# this changes the behaviour of result.clone to create a new reference
2303
2379
# rather than a copy of the content of the branch.
2304
2380
# I did not use a proxy object because that needs much more extensive
2386
2462
def __init__(self, _format=None,
2387
2463
_control_files=None, a_bzrdir=None, name=None,
2388
_repository=None, ignore_fallbacks=False):
2464
_repository=None, ignore_fallbacks=False,
2465
possible_transports=None):
2389
2466
"""Create new branch object at a particular location."""
2390
2467
if a_bzrdir is None:
2391
2468
raise ValueError('a_bzrdir must be supplied')
2393
self.bzrdir = a_bzrdir
2394
self._base = self.bzrdir.transport.clone('..').base
2470
raise ValueError('name must be supplied')
2471
self.bzrdir = a_bzrdir
2472
self._user_transport = self.bzrdir.transport.clone('..')
2474
self._user_transport.set_segment_parameter(
2475
"branch", urlutils.escape(name))
2476
self._base = self._user_transport.base
2395
2477
self.name = name
2396
# XXX: We should be able to just do
2397
# self.base = self.bzrdir.root_transport.base
2398
# but this does not quite work yet -- mbp 20080522
2399
2478
self._format = _format
2400
2479
if _control_files is None:
2401
2480
raise ValueError('BzrBranch _control_files is None')
2402
2481
self.control_files = _control_files
2403
2482
self._transport = _control_files._transport
2404
2483
self.repository = _repository
2405
Branch.__init__(self)
2484
Branch.__init__(self, possible_transports)
2407
2486
def __str__(self):
2408
if self.name is None:
2409
return '%s(%s)' % (self.__class__.__name__, self.user_url)
2411
return '%s(%s,%s)' % (self.__class__.__name__, self.user_url,
2487
return '%s(%s)' % (self.__class__.__name__, self.user_url)
2414
2489
__repr__ = __str__
2420
2495
base = property(_get_base, doc="The URL for the root of this branch.")
2498
def user_transport(self):
2499
return self._user_transport
2422
2501
def _get_config(self):
2423
return TransportConfig(self._transport, 'branch.conf')
2502
return _mod_config.TransportConfig(self._transport, 'branch.conf')
2504
def _get_config_store(self):
2505
return _mod_config.BranchStore(self)
2425
2507
def is_locked(self):
2426
2508
return self.control_files.is_locked()
2507
2589
raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2508
2590
revision_id = _mod_revision.ensure_null(revision_id)
2509
2591
old_revno, old_revid = self.last_revision_info()
2510
if self._get_append_revisions_only():
2592
if self.get_append_revisions_only():
2511
2593
self._check_history_violation(revision_id)
2512
2594
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2513
2595
self._write_last_revision_info(revno, revision_id)
2656
2738
self._transport.put_bytes('last-revision', out_string,
2657
2739
mode=self.bzrdir._get_file_mode())
2742
def update_feature_flags(self, updated_flags):
2743
"""Update the feature flags for this branch.
2745
:param updated_flags: Dictionary mapping feature names to necessities
2746
A necessity can be None to indicate the feature should be removed
2748
self._format._update_feature_flags(updated_flags)
2749
self.control_transport.put_bytes('format', self._format.as_string())
2660
2752
class FullHistoryBzrBranch(BzrBranch):
2661
2753
"""Bzr branch which contains the full revision history."""
2768
2860
class BzrBranch8(BzrBranch):
2769
2861
"""A branch that stores tree-reference locations."""
2771
def _open_hook(self):
2863
def _open_hook(self, possible_transports=None):
2772
2864
if self._ignore_fallbacks:
2866
if possible_transports is None:
2867
possible_transports = [self.bzrdir.root_transport]
2775
2869
url = self.get_stacked_on_url()
2776
2870
except (errors.UnstackableRepositoryFormat, errors.NotStacked,
2784
2878
raise AssertionError(
2785
2879
"'transform_fallback_location' hook %s returned "
2786
2880
"None, not a URL." % hook_name)
2787
self._activate_fallback_location(url)
2881
self._activate_fallback_location(url,
2882
possible_transports=possible_transports)
2789
2884
def __init__(self, *args, **kwargs):
2790
2885
self._ignore_fallbacks = kwargs.get('ignore_fallbacks', False)
2908
3003
"""See Branch.set_push_location."""
2909
3004
self._master_branch_cache = None
2911
config = self.get_config()
3006
conf = self.get_config_stack()
2912
3007
if location is None:
2913
if config.get_user_option('bound') != 'True':
3008
if not conf.get('bound'):
2916
config.set_user_option('bound', 'False', warn_masked=True)
3011
conf.set('bound', 'False')
2919
3014
self._set_config_location('bound_location', location,
2921
config.set_user_option('bound', 'True', warn_masked=True)
3016
conf.set('bound', 'True')
2924
3019
def _get_bound_location(self, bound):
2925
3020
"""Return the bound location in the config file.
2927
3022
Return None if the bound parameter does not match"""
2928
config = self.get_config()
2929
config_bound = (config.get_user_option('bound') == 'True')
2930
if config_bound != bound:
3023
conf = self.get_config_stack()
3024
if conf.get('bound') != bound:
2932
return self._get_config_location('bound_location', config=config)
3026
return self._get_config_location('bound_location', config=conf)
2934
3028
def get_bound_location(self):
2935
"""See Branch.set_push_location."""
3029
"""See Branch.get_bound_location."""
2936
3030
return self._get_bound_location(True)
2938
3032
def get_old_bound_location(self):
2945
3039
## self._check_stackable_repo()
2946
3040
# stacked_on_location is only ever defined in branch.conf, so don't
2947
3041
# waste effort reading the whole stack of config files.
2948
config = self.get_config()._get_branch_data_config()
3042
conf = _mod_config.BranchOnlyStack(self)
2949
3043
stacked_url = self._get_config_location('stacked_on_location',
2951
3045
if stacked_url is None:
2952
3046
raise errors.NotStacked(self)
2955
def _get_append_revisions_only(self):
2956
return self.get_config(
2957
).get_user_option_as_bool('append_revisions_only')
3047
return stacked_url.encode('utf-8')
2959
3049
@needs_read_lock
2960
3050
def get_rev_id(self, revno, history=None):
2990
3080
except errors.RevisionNotPresent, e:
2991
3081
raise errors.GhostRevisionsHaveNoRevno(revision_id, e.revision_id)
2992
3082
index = len(self._partial_revision_history_cache) - 1
3084
raise errors.NoSuchRevision(self, revision_id)
2993
3085
if self._partial_revision_history_cache[index] != revision_id:
2994
3086
raise errors.NoSuchRevision(self, revision_id)
2995
3087
return self.revno() - index
3058
3151
return self.new_revno - self.old_revno
3060
3153
def report(self, to_file):
3154
tag_conflicts = getattr(self, "tag_conflicts", None)
3155
tag_updates = getattr(self, "tag_updates", None)
3061
3156
if not is_quiet():
3062
if self.old_revid == self.new_revid:
3063
to_file.write('No revisions to pull.\n')
3157
if self.old_revid != self.new_revid:
3065
3158
to_file.write('Now on revision %d.\n' % self.new_revno)
3160
to_file.write('%d tag(s) updated.\n' % len(tag_updates))
3161
if self.old_revid == self.new_revid and not tag_updates:
3162
if not tag_conflicts:
3163
to_file.write('No revisions or tags to pull.\n')
3165
to_file.write('No revisions to pull.\n')
3066
3166
self._show_tag_conficts(to_file)
3094
3194
return self.new_revno - self.old_revno
3096
3196
def report(self, to_file):
3097
"""Write a human-readable description of the result."""
3098
if self.old_revid == self.new_revid:
3099
note('No new revisions to push.')
3101
note('Pushed up to revision %d.' % self.new_revno)
3197
# TODO: This function gets passed a to_file, but then
3198
# ignores it and calls note() instead. This is also
3199
# inconsistent with PullResult(), which writes to stdout.
3200
# -- JRV20110901, bug #838853
3201
tag_conflicts = getattr(self, "tag_conflicts", None)
3202
tag_updates = getattr(self, "tag_updates", None)
3204
if self.old_revid != self.new_revid:
3205
note(gettext('Pushed up to revision %d.') % self.new_revno)
3207
note(ngettext('%d tag updated.', '%d tags updated.', len(tag_updates)) % len(tag_updates))
3208
if self.old_revid == self.new_revid and not tag_updates:
3209
if not tag_conflicts:
3210
note(gettext('No new revisions or tags to push.'))
3212
note(gettext('No new revisions to push.'))
3102
3213
self._show_tag_conficts(to_file)
3118
3229
:param verbose: Requests more detailed display of what was checked,
3121
note('checked branch %s format %s', self.branch.user_url,
3122
self.branch._format)
3232
note(gettext('checked branch {0} format {1}').format(
3233
self.branch.user_url, self.branch._format))
3123
3234
for error in self.errors:
3124
note('found error:%s', error)
3235
note(gettext('found error:%s'), error)
3127
3238
class Converter5to6(object):
3412
3523
self._update_revisions(stop_revision, overwrite=overwrite,
3414
3525
if self.source._push_should_merge_tags():
3415
result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
3526
result.tag_updates, result.tag_conflicts = (
3527
self.source.tags.merge_to(self.target.tags, overwrite))
3417
3528
result.new_revno, result.new_revid = self.target.last_revision_info()
3502
3613
# TODO: The old revid should be specified when merging tags,
3503
3614
# so a tags implementation that versions tags can only
3504
3615
# pull in the most recent changes. -- JRV20090506
3505
result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
3506
overwrite, ignore_master=not merge_tags_to_master)
3616
result.tag_updates, result.tag_conflicts = (
3617
self.source.tags.merge_to(self.target.tags, overwrite,
3618
ignore_master=not merge_tags_to_master))
3507
3619
result.new_revno, result.new_revid = self.target.last_revision_info()
3508
3620
if _hook_master:
3509
3621
result.master_branch = _hook_master
added
removed
bzrlib/branch.py
