21
24
lazy_import(globals(), """
23
26
from bzrlib import (
27
config as _mod_config,
36
revision as _mod_revision,
31
config as _mod_config,
40
revision as _mod_revision,
43
48
from bzrlib.i18n import gettext, ngettext
51
# Explicitly import bzrlib.bzrdir so that the BzrProber
52
# is guaranteed to be registered.
46
55
from bzrlib import (
49
59
from bzrlib.decorators import (
84
94
def user_transport(self):
85
95
return self.bzrdir.user_transport
87
def __init__(self, *ignored, **ignored_too):
97
def __init__(self, possible_transports=None):
88
98
self.tags = self._format.make_tags(self)
89
99
self._revision_history_cache = None
90
100
self._revision_id_to_revno_cache = None
94
104
self._last_revision_info_cache = None
95
105
self._master_branch_cache = None
96
106
self._merge_sorted_revisions_cache = None
107
self._open_hook(possible_transports)
98
108
hooks = Branch.hooks['open']
99
109
for hook in hooks:
102
def _open_hook(self):
112
def _open_hook(self, possible_transports):
103
113
"""Called by init to allow simpler extension of the base class."""
105
def _activate_fallback_location(self, url):
115
def _activate_fallback_location(self, url, possible_transports):
106
116
"""Activate the branch/repository from url as a fallback repository."""
107
117
for existing_fallback_repo in self.repository._fallback_repositories:
108
118
if existing_fallback_repo.user_url == url:
109
119
# This fallback is already configured. This probably only
110
# happens because BzrDir.sprout is a horrible mess. To avoid
120
# happens because ControlDir.sprout is a horrible mess. To avoid
111
121
# confusing _unstack we don't add this a second time.
112
122
mutter('duplicate activation of fallback %r on %r', url, self)
114
repo = self._get_fallback_repository(url)
124
repo = self._get_fallback_repository(url, possible_transports)
115
125
if repo.has_same_location(self.repository):
116
126
raise errors.UnstackableLocationError(self.user_url, url)
117
127
self.repository.add_fallback_repository(repo)
171
181
For instance, if the branch is at URL/.bzr/branch,
172
182
Branch.open(URL) -> a Branch instance.
174
control = bzrdir.BzrDir.open(base, _unsupported,
175
possible_transports=possible_transports)
176
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)
179
def open_from_transport(transport, name=None, _unsupported=False):
190
def open_from_transport(transport, name=None, _unsupported=False,
191
possible_transports=None):
180
192
"""Open the branch rooted at transport"""
181
control = bzrdir.BzrDir.open_from_transport(transport, _unsupported)
182
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)
185
198
def open_containing(url, possible_transports=None):
193
206
format, UnknownFormatError or UnsupportedFormatError are raised.
194
207
If there is one, it is returned, along with the unused portion of url.
196
control, relpath = bzrdir.BzrDir.open_containing(url,
209
control, relpath = controldir.ControlDir.open_containing(url,
197
210
possible_transports)
198
return control.open_branch(), relpath
211
branch = control.open_branch(possible_transports=possible_transports)
212
return (branch, relpath)
200
214
def _push_should_merge_tags(self):
201
215
"""Should _basic_push merge this branch's tags into the target?
238
252
raise NotImplementedError(self._get_config)
240
def _get_fallback_repository(self, url):
254
def _get_fallback_repository(self, url, possible_transports):
241
255
"""Get the repository we fallback to at url."""
242
256
url = urlutils.join(self.base, url)
243
a_branch = Branch.open(url,
244
possible_transports=[self.bzrdir.root_transport])
257
a_branch = Branch.open(url, possible_transports=possible_transports)
245
258
return a_branch.repository
658
671
if not self._format.supports_set_append_revisions_only():
660
return self.get_config(
661
).get_user_option_as_bool('append_revisions_only')
673
return self.get_config_stack().get('append_revisions_only')
663
675
def set_append_revisions_only(self, enabled):
664
676
if not self._format.supports_set_append_revisions_only():
665
677
raise errors.UpgradeRequired(self.user_url)
670
self.get_config().set_user_option('append_revisions_only', value,
678
self.get_config_stack().set('append_revisions_only', enabled)
673
680
def set_reference_info(self, file_id, tree_path, branch_location):
674
681
"""Set the branch location to use for a tree reference."""
704
711
raise errors.UpgradeRequired(self.user_url)
706
def get_commit_builder(self, parents, config=None, timestamp=None,
713
def get_commit_builder(self, parents, config_stack=None, timestamp=None,
707
714
timezone=None, committer=None, revprops=None,
708
715
revision_id=None, lossy=False):
709
716
"""Obtain a CommitBuilder for this branch.
719
726
represented, when pushing to a foreign VCS
723
config = self.get_config()
729
if config_stack is None:
730
config_stack = self.get_config_stack()
725
return self.repository.get_commit_builder(self, parents, config,
732
return self.repository.get_commit_builder(self, parents, config_stack,
726
733
timestamp, timezone, committer, revprops, revision_id,
743
@deprecated_method(deprecated_in((2, 5, 0)))
736
744
def get_revision_delta(self, revno):
737
745
"""Return the delta for one revision.
739
747
The delta is relative to its mainline predecessor, or the
740
748
empty tree for revision 1.
742
rh = self.revision_history()
743
if not (1 <= revno <= len(rh)):
751
revid = self.get_rev_id(revno)
752
except errors.NoSuchRevision:
744
753
raise errors.InvalidRevisionNumber(revno)
745
return self.repository.get_revision_delta(rh[revno-1])
754
return self.repository.get_revision_delta(revid)
747
756
def get_stacked_on_url(self):
748
757
"""Get the URL this branch is stacked against.
879
889
# stream from one of them to the other. This does mean doing
880
890
# separate SSH connection setup, but unstacking is not a
881
891
# common operation so it's tolerable.
882
new_bzrdir = bzrdir.BzrDir.open(self.bzrdir.root_transport.base)
892
new_bzrdir = controldir.ControlDir.open(
893
self.bzrdir.root_transport.base)
883
894
new_repository = new_bzrdir.find_repository()
884
895
if new_repository._fallback_repositories:
885
896
raise AssertionError("didn't expect %r to have "
928
939
tags_to_fetch = set(self.tags.get_reverse_tag_dict())
929
940
except errors.TagsNotSupported:
930
941
tags_to_fetch = set()
931
fetch_spec = _mod_graph.NotInOtherForRevs(self.repository,
942
fetch_spec = vf_search.NotInOtherForRevs(self.repository,
932
943
old_repository, required_ids=[self.last_revision()],
933
944
if_present_ids=tags_to_fetch, find_ghosts=True).execute()
934
945
self.repository.fetch(old_repository, fetch_spec=fetch_spec)
1155
1170
def _set_config_location(self, name, url, config=None,
1156
1171
make_relative=False):
1157
1172
if config is None:
1158
config = self.get_config()
1173
config = self.get_config_stack()
1159
1174
if url is None:
1161
1176
elif make_relative:
1162
1177
url = urlutils.relative_url(self.base, url)
1163
config.set_user_option(name, url, warn_masked=True)
1178
config.set(name, url)
1165
1180
def _get_config_location(self, name, config=None):
1166
1181
if config is None:
1167
config = self.get_config()
1168
location = config.get_user_option(name)
1182
config = self.get_config_stack()
1183
location = config.get(name)
1169
1184
if location == '':
1170
1185
location = None
1171
1186
return location
1173
1188
def get_child_submit_format(self):
1174
1189
"""Return the preferred format of submissions to this branch."""
1175
return self.get_config().get_user_option("child_submit_format")
1190
return self.get_config_stack().get('child_submit_format')
1177
1192
def get_submit_branch(self):
1178
1193
"""Return the submit location of the branch.
1210
1224
self._set_config_location('public_branch', location)
1212
1226
def get_push_location(self):
1213
"""Return the None or the location to push this branch to."""
1214
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')
1217
1230
def set_push_location(self, location):
1218
1231
"""Set a new push location for this branch."""
1444
1457
t = transport.get_transport(to_location)
1445
1458
t.ensure_base()
1446
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
1447
1477
if lightweight:
1448
checkout = format.initialize_on_transport(t)
1449
from_branch = BranchReferenceFormat().initialize(checkout,
1478
from_branch = checkout.set_branch_reference(target_branch=self)
1452
checkout_branch = bzrdir.BzrDir.create_branch_convenience(
1453
to_location, force_new_tree=False, format=format)
1454
checkout = checkout_branch.bzrdir
1480
policy = checkout.determine_repository_policy()
1481
repo = policy.acquire_repository()[0]
1482
checkout_branch = checkout.create_branch()
1455
1483
checkout_branch.bind(self)
1456
1484
# pull up to the specified revision_id to set the initial
1457
1485
# branch tip correctly, and seed it with history.
1458
1486
checkout_branch.pull(self, stop_revision=revision_id)
1460
1488
tree = checkout.create_workingtree(revision_id,
1461
1489
from_branch=from_branch,
1462
1490
accelerator_tree=accelerator_tree,
1551
1579
heads that must be fetched if present, but no error is necessary if
1552
1580
they are not present.
1554
# 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.
1556
1584
must_fetch = set([self.last_revision()])
1557
1585
if_present_fetch = set()
1558
c = self.get_config()
1559
include_tags = c.get_user_option_as_bool('branch.fetch_tags',
1586
if self.get_config_stack().get('branch.fetch_tags'):
1563
1588
if_present_fetch = set(self.tags.get_reverse_tag_dict())
1564
1589
except errors.TagsNotSupported:
1593
1618
return not (self == other)
1596
def find_format(klass, a_bzrdir, name=None):
1597
"""Return the format for the branch object in a_bzrdir."""
1599
transport = a_bzrdir.get_branch_transport(None, name=name)
1600
format_string = transport.get_bytes("format")
1601
return format_registry.get(format_string)
1602
except errors.NoSuchFile:
1603
raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1605
raise errors.UnknownFormatError(format=format_string, kind='branch')
1608
1621
@deprecated_method(deprecated_in((2, 4, 0)))
1609
1622
def get_default_format(klass):
1610
1623
"""Return the current default format."""
1621
1634
return format_registry._get_all()
1623
def get_reference(self, a_bzrdir, name=None):
1624
"""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.
1626
1639
format probing must have been completed before calling
1627
1640
this method - it is assumed that the format of the branch
1628
in a_bzrdir is correct.
1641
in controldir is correct.
1630
:param a_bzrdir: The bzrdir to get the branch data from.
1643
:param controldir: The controldir to get the branch data from.
1631
1644
:param name: Name of the colocated branch to fetch
1632
1645
:return: None if the branch is not a reference branch.
1637
def set_reference(self, a_bzrdir, name, to_branch):
1638
"""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.
1640
1653
format probing must have been completed before calling
1641
1654
this method - it is assumed that the format of the branch
1642
in a_bzrdir is correct.
1655
in controldir is correct.
1644
:param a_bzrdir: The bzrdir to set the branch reference for.
1657
:param controldir: The controldir to set the branch reference for.
1645
1658
:param name: Name of colocated branch to set, None for default
1646
1659
:param to_branch: branch that the checkout is to reference
1648
1661
raise NotImplementedError(self.set_reference)
1650
def get_format_string(self):
1651
"""Return the ASCII format string that identifies this format."""
1652
raise NotImplementedError(self.get_format_string)
1654
1663
def get_format_description(self):
1655
1664
"""Return the short format description for this format."""
1656
1665
raise NotImplementedError(self.get_format_description)
1658
def _run_post_branch_init_hooks(self, a_bzrdir, name, branch):
1667
def _run_post_branch_init_hooks(self, controldir, name, branch):
1659
1668
hooks = Branch.hooks['post_branch_init']
1662
params = BranchInitHookParams(self, a_bzrdir, name, branch)
1671
params = BranchInitHookParams(self, controldir, name, branch)
1663
1672
for hook in hooks:
1666
def initialize(self, a_bzrdir, name=None, repository=None,
1675
def initialize(self, controldir, name=None, repository=None,
1667
1676
append_revisions_only=None):
1668
"""Create a branch of this format in a_bzrdir.
1677
"""Create a branch of this format in controldir.
1670
1679
:param name: Name of the colocated branch to create.
1672
1681
raise NotImplementedError(self.initialize)
1705
1714
raise NotImplementedError(self.network_name)
1707
def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False,
1708
found_repository=None):
1709
"""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.
1711
:param a_bzrdir: A BzrDir that contains a branch.
1720
:param controldir: A ControlDir that contains a branch.
1712
1721
:param name: Name of colocated branch to open
1713
1722
:param _found: a private parameter, do not use it. It is used to
1714
1723
indicate if format probing has already be done.
1943
1952
branch, which refer to the original branch.
1946
def __init__(self, format, a_bzrdir, name, branch):
1955
def __init__(self, format, controldir, name, branch):
1947
1956
"""Create a group of BranchInitHook parameters.
1949
1958
:param format: the branch format
1950
:param a_bzrdir: the BzrDir where the branch will be/has been
1959
:param controldir: the ControlDir where the branch will be/has been
1952
1961
:param name: name of colocated branch, if any (or None)
1953
1962
:param branch: the branch created
1982
1991
def __init__(self, control_dir, to_branch, force, revision_id):
1983
1992
"""Create a group of SwitchHook parameters.
1985
:param control_dir: BzrDir of the checkout to change
1994
:param control_dir: ControlDir of the checkout to change
1986
1995
:param to_branch: branch that the checkout is to reference
1987
1996
:param force: skip the check for local commits in a heavy checkout
1988
1997
:param revision_id: revision ID to switch to (or None)
2001
2010
self.revision_id)
2004
class BranchFormatMetadir(BranchFormat):
2005
"""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)
2007
2034
def _branch_class(self):
2008
2035
"""What class to instantiate on open calls."""
2026
2053
:param name: Name of colocated branch to create, if any
2027
2054
:return: a branch in this format
2057
name = a_bzrdir._get_selected_branch()
2029
2058
mutter('creating branch %r in %s', self, a_bzrdir.user_url)
2030
2059
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
2031
2060
control_files = lockable_files.LockableFiles(branch_transport,
2045
2074
self._run_post_branch_init_hooks(a_bzrdir, name, branch)
2048
def network_name(self):
2049
"""A simple byte string uniquely identifying this format for RPC calls.
2051
Metadir branch formats use their format string.
2053
return self.get_format_string()
2055
2077
def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False,
2056
found_repository=None):
2078
found_repository=None, possible_transports=None):
2057
2079
"""See BranchFormat.open()."""
2081
name = a_bzrdir._get_selected_branch()
2059
format = BranchFormat.find_format(a_bzrdir, name=name)
2083
format = BranchFormatMetadir.find_format(a_bzrdir, name=name)
2060
2084
if format.__class__ != self.__class__:
2061
2085
raise AssertionError("wrong format %r found for %r" %
2062
2086
(format, self))
2072
2096
a_bzrdir=a_bzrdir,
2073
2097
_repository=found_repository,
2074
ignore_fallbacks=ignore_fallbacks)
2098
ignore_fallbacks=ignore_fallbacks,
2099
possible_transports=possible_transports)
2075
2100
except errors.NoSuchFile:
2076
2101
raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
2079
super(BranchFormatMetadir, self).__init__()
2080
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
2081
self._matchingbzrdir.set_branch_format(self)
2104
def _matchingbzrdir(self):
2105
ret = bzrdir.BzrDirMetaFormat1()
2106
ret.set_branch_format(self)
2083
2109
def supports_tags(self):
2086
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)
2090
2124
class BzrBranchFormat5(BranchFormatMetadir):
2091
2125
"""Bzr branch format 5.
2285
2324
mutter('creating branch reference in %s', a_bzrdir.user_url)
2286
2325
if a_bzrdir._format.fixed_components:
2287
2326
raise errors.IncompatibleFormat(self, a_bzrdir._format)
2328
name = a_bzrdir._get_selected_branch()
2288
2329
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
2289
2330
branch_transport.put_bytes('location',
2290
target_branch.bzrdir.user_url)
2291
branch_transport.put_bytes('format', self.get_format_string())
2293
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,
2294
2334
possible_transports=[target_branch.bzrdir.root_transport])
2295
2335
self._run_post_branch_init_hooks(a_bzrdir, name, branch)
2299
super(BranchReferenceFormat, self).__init__()
2300
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
2301
self._matchingbzrdir.set_branch_format(self)
2303
2338
def _make_reference_clone_function(format, a_branch):
2304
2339
"""Create a clone() routine for a branch dynamically."""
2305
2340
def clone(to_bzrdir, revision_id=None,
2328
2363
:param possible_transports: An optional reusable transports list.
2366
name = a_bzrdir._get_selected_branch()
2331
format = BranchFormat.find_format(a_bzrdir, name=name)
2368
format = BranchFormatMetadir.find_format(a_bzrdir, name=name)
2332
2369
if format.__class__ != self.__class__:
2333
2370
raise AssertionError("wrong format %r found for %r" %
2334
2371
(format, self))
2335
2372
if location is None:
2336
2373
location = self.get_reference(a_bzrdir, name)
2337
real_bzrdir = bzrdir.BzrDir.open(
2374
real_bzrdir = controldir.ControlDir.open(
2338
2375
location, possible_transports=possible_transports)
2339
result = real_bzrdir.open_branch(name=name,
2340
ignore_fallbacks=ignore_fallbacks)
2376
result = real_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks,
2377
possible_transports=possible_transports)
2341
2378
# this changes the behaviour of result.clone to create a new reference
2342
2379
# rather than a copy of the content of the branch.
2343
2380
# I did not use a proxy object because that needs much more extensive
2425
2462
def __init__(self, _format=None,
2426
2463
_control_files=None, a_bzrdir=None, name=None,
2427
_repository=None, ignore_fallbacks=False):
2464
_repository=None, ignore_fallbacks=False,
2465
possible_transports=None):
2428
2466
"""Create new branch object at a particular location."""
2429
2467
if a_bzrdir is None:
2430
2468
raise ValueError('a_bzrdir must be supplied')
2432
self.bzrdir = a_bzrdir
2433
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
2434
2477
self.name = name
2435
# XXX: We should be able to just do
2436
# self.base = self.bzrdir.root_transport.base
2437
# but this does not quite work yet -- mbp 20080522
2438
2478
self._format = _format
2439
2479
if _control_files is None:
2440
2480
raise ValueError('BzrBranch _control_files is None')
2441
2481
self.control_files = _control_files
2442
2482
self._transport = _control_files._transport
2443
2483
self.repository = _repository
2444
Branch.__init__(self)
2484
Branch.__init__(self, possible_transports)
2446
2486
def __str__(self):
2447
if self.name is None:
2448
return '%s(%s)' % (self.__class__.__name__, self.user_url)
2450
return '%s(%s,%s)' % (self.__class__.__name__, self.user_url,
2487
return '%s(%s)' % (self.__class__.__name__, self.user_url)
2453
2489
__repr__ = __str__
2695
2738
self._transport.put_bytes('last-revision', out_string,
2696
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())
2699
2752
class FullHistoryBzrBranch(BzrBranch):
2700
2753
"""Bzr branch which contains the full revision history."""
2807
2860
class BzrBranch8(BzrBranch):
2808
2861
"""A branch that stores tree-reference locations."""
2810
def _open_hook(self):
2863
def _open_hook(self, possible_transports=None):
2811
2864
if self._ignore_fallbacks:
2866
if possible_transports is None:
2867
possible_transports = [self.bzrdir.root_transport]
2814
2869
url = self.get_stacked_on_url()
2815
2870
except (errors.UnstackableRepositoryFormat, errors.NotStacked,
2823
2878
raise AssertionError(
2824
2879
"'transform_fallback_location' hook %s returned "
2825
2880
"None, not a URL." % hook_name)
2826
self._activate_fallback_location(url)
2881
self._activate_fallback_location(url,
2882
possible_transports=possible_transports)
2828
2884
def __init__(self, *args, **kwargs):
2829
2885
self._ignore_fallbacks = kwargs.get('ignore_fallbacks', False)
2947
3003
"""See Branch.set_push_location."""
2948
3004
self._master_branch_cache = None
2950
config = self.get_config()
3006
conf = self.get_config_stack()
2951
3007
if location is None:
2952
if config.get_user_option('bound') != 'True':
3008
if not conf.get('bound'):
2955
config.set_user_option('bound', 'False', warn_masked=True)
3011
conf.set('bound', 'False')
2958
3014
self._set_config_location('bound_location', location,
2960
config.set_user_option('bound', 'True', warn_masked=True)
3016
conf.set('bound', 'True')
2963
3019
def _get_bound_location(self, bound):
2964
3020
"""Return the bound location in the config file.
2966
3022
Return None if the bound parameter does not match"""
2967
config = self.get_config()
2968
config_bound = (config.get_user_option('bound') == 'True')
2969
if config_bound != bound:
3023
conf = self.get_config_stack()
3024
if conf.get('bound') != bound:
2971
return self._get_config_location('bound_location', config=config)
3026
return self._get_config_location('bound_location', config=conf)
2973
3028
def get_bound_location(self):
2974
"""See Branch.set_push_location."""
3029
"""See Branch.get_bound_location."""
2975
3030
return self._get_bound_location(True)
2977
3032
def get_old_bound_location(self):
2984
3039
## self._check_stackable_repo()
2985
3040
# stacked_on_location is only ever defined in branch.conf, so don't
2986
3041
# waste effort reading the whole stack of config files.
2987
config = self.get_config()._get_branch_data_config()
3042
conf = _mod_config.BranchOnlyStack(self)
2988
3043
stacked_url = self._get_config_location('stacked_on_location',
2990
3045
if stacked_url is None:
2991
3046
raise errors.NotStacked(self)
3047
return stacked_url.encode('utf-8')
2994
3049
@needs_read_lock
2995
3050
def get_rev_id(self, revno, history=None):
3025
3080
except errors.RevisionNotPresent, e:
3026
3081
raise errors.GhostRevisionsHaveNoRevno(revision_id, e.revision_id)
3027
3082
index = len(self._partial_revision_history_cache) - 1
3084
raise errors.NoSuchRevision(self, revision_id)
3028
3085
if self._partial_revision_history_cache[index] != revision_id:
3029
3086
raise errors.NoSuchRevision(self, revision_id)
3030
3087
return self.revno() - index
added
removed
bzrlib/branch.py
