112
104
self._client = client._SmartClient(medium)
114
106
self._client = _client
121
return '%s(%r)' % (self.__class__.__name__, self._client)
123
def _probe_bzrdir(self):
124
medium = self._client._medium
125
109
path = self._path_for_remote_call(self._client)
126
if medium._is_remote_before((2, 1)):
130
self._rpc_open_2_1(path)
132
except errors.UnknownSmartMethod:
133
medium._remember_remote_is_before((2, 1))
136
def _rpc_open_2_1(self, path):
137
response = self._call('BzrDir.open_2.1', path)
138
if response == ('no',):
139
raise errors.NotBranchError(path=self.root_transport.base)
140
elif response[0] == 'yes':
141
if response[1] == 'yes':
142
self._has_working_tree = True
143
elif response[1] == 'no':
144
self._has_working_tree = False
146
raise errors.UnexpectedSmartServerResponse(response)
148
raise errors.UnexpectedSmartServerResponse(response)
150
def _rpc_open(self, path):
151
110
response = self._call('BzrDir.open', path)
152
111
if response not in [('yes',), ('no',)]:
153
112
raise errors.UnexpectedSmartServerResponse(response)
154
113
if response == ('no',):
155
raise errors.NotBranchError(path=self.root_transport.base)
114
raise errors.NotBranchError(path=transport.base)
157
116
def _ensure_real(self):
158
117
"""Ensure that there is a _real_bzrdir set.
292
236
def _get_branch_reference(self):
293
237
path = self._path_for_remote_call(self._client)
294
238
medium = self._client._medium
296
('BzrDir.open_branchV3', (2, 1)),
297
('BzrDir.open_branchV2', (1, 13)),
298
('BzrDir.open_branch', None),
300
for verb, required_version in candidate_calls:
301
if required_version and medium._is_remote_before(required_version):
239
if not medium._is_remote_before((1, 13)):
304
response = self._call(verb, path)
241
response = self._call('BzrDir.open_branchV2', path)
242
if response[0] not in ('ref', 'branch'):
243
raise errors.UnexpectedSmartServerResponse(response)
305
245
except errors.UnknownSmartMethod:
306
if required_version is None:
308
medium._remember_remote_is_before(required_version)
311
if verb == 'BzrDir.open_branch':
312
if response[0] != 'ok':
313
raise errors.UnexpectedSmartServerResponse(response)
314
if response[1] != '':
315
return ('ref', response[1])
317
return ('branch', '')
318
if response[0] not in ('ref', 'branch'):
246
medium._remember_remote_is_before((1, 13))
247
response = self._call('BzrDir.open_branch', path)
248
if response[0] != 'ok':
319
249
raise errors.UnexpectedSmartServerResponse(response)
250
if response[1] != '':
251
return ('ref', response[1])
253
return ('branch', '')
322
255
def _get_tree_branch(self):
323
256
"""See BzrDir._get_tree_branch()."""
324
257
return None, self.open_branch()
326
def open_branch(self, name=None, unsupported=False,
327
ignore_fallbacks=False):
259
def open_branch(self, _unsupported=False):
329
261
raise NotImplementedError('unsupported flag support not implemented yet.')
330
262
if self._next_open_branch_result is not None:
331
263
# See create_branch for details.
753
639
self._ensure_real()
754
640
return self._real_repository.suspend_write_group()
756
def get_missing_parent_inventories(self, check_for_missing_texts=True):
758
return self._real_repository.get_missing_parent_inventories(
759
check_for_missing_texts=check_for_missing_texts)
761
def _get_rev_id_for_revno_vfs(self, revno, known_pair):
763
return self._real_repository.get_rev_id_for_revno(
766
def get_rev_id_for_revno(self, revno, known_pair):
767
"""See Repository.get_rev_id_for_revno."""
768
path = self.bzrdir._path_for_remote_call(self._client)
770
if self._client._medium._is_remote_before((1, 17)):
771
return self._get_rev_id_for_revno_vfs(revno, known_pair)
772
response = self._call(
773
'Repository.get_rev_id_for_revno', path, revno, known_pair)
774
except errors.UnknownSmartMethod:
775
self._client._medium._remember_remote_is_before((1, 17))
776
return self._get_rev_id_for_revno_vfs(revno, known_pair)
777
if response[0] == 'ok':
778
return True, response[1]
779
elif response[0] == 'history-incomplete':
780
known_pair = response[1:3]
781
for fallback in self._fallback_repositories:
782
found, result = fallback.get_rev_id_for_revno(revno, known_pair)
787
# Not found in any fallbacks
788
return False, known_pair
790
raise errors.UnexpectedSmartServerResponse(response)
792
642
def _ensure_real(self):
793
643
"""Ensure that there is a _real_repository set.
873
723
"""Return a source for streaming from this repository."""
874
724
return RemoteStreamSource(self, to_format)
877
726
def has_revision(self, revision_id):
878
"""True if this repository has a copy of the revision."""
879
# Copy of bzrlib.repository.Repository.has_revision
880
return revision_id in self.has_revisions((revision_id,))
727
"""See Repository.has_revision()."""
728
if revision_id == NULL_REVISION:
729
# The null revision is always present.
731
path = self.bzrdir._path_for_remote_call(self._client)
732
response = self._call('Repository.has_revision', path, revision_id)
733
if response[0] not in ('yes', 'no'):
734
raise errors.UnexpectedSmartServerResponse(response)
735
if response[0] == 'yes':
737
for fallback_repo in self._fallback_repositories:
738
if fallback_repo.has_revision(revision_id):
883
742
def has_revisions(self, revision_ids):
884
"""Probe to find out the presence of multiple revisions.
886
:param revision_ids: An iterable of revision_ids.
887
:return: A set of the revision_ids that were present.
889
# Copy of bzrlib.repository.Repository.has_revisions
890
parent_map = self.get_parent_map(revision_ids)
891
result = set(parent_map)
892
if _mod_revision.NULL_REVISION in revision_ids:
893
result.add(_mod_revision.NULL_REVISION)
743
"""See Repository.has_revisions()."""
744
# FIXME: This does many roundtrips, particularly when there are
745
# fallback repositories. -- mbp 20080905
747
for revision_id in revision_ids:
748
if self.has_revision(revision_id):
749
result.add(revision_id)
896
def _has_same_fallbacks(self, other_repo):
897
"""Returns true if the repositories have the same fallbacks."""
898
# XXX: copied from Repository; it should be unified into a base class
899
# <https://bugs.edge.launchpad.net/bzr/+bug/401622>
900
my_fb = self._fallback_repositories
901
other_fb = other_repo._fallback_repositories
902
if len(my_fb) != len(other_fb):
904
for f, g in zip(my_fb, other_fb):
905
if not f.has_same_location(g):
909
752
def has_same_location(self, other):
910
# TODO: Move to RepositoryBase and unify with the regular Repository
911
# one; unfortunately the tests rely on slightly different behaviour at
912
# present -- mbp 20090710
913
753
return (self.__class__ is other.__class__ and
914
754
self.bzrdir.transport.base == other.bzrdir.transport.base)
1087
900
if isinstance(repository, RemoteRepository):
1088
901
raise AssertionError()
1089
902
self._real_repository = repository
1090
# three code paths happen here:
1091
# 1) old servers, RemoteBranch.open() calls _ensure_real before setting
1092
# up stacking. In this case self._fallback_repositories is [], and the
1093
# real repo is already setup. Preserve the real repo and
1094
# RemoteRepository.add_fallback_repository will avoid adding
1096
# 2) new servers, RemoteBranch.open() sets up stacking, and when
1097
# ensure_real is triggered from a branch, the real repository to
1098
# set already has a matching list with separate instances, but
1099
# as they are also RemoteRepositories we don't worry about making the
1100
# lists be identical.
1101
# 3) new servers, RemoteRepository.ensure_real is triggered before
1102
# RemoteBranch.ensure real, in this case we get a repo with no fallbacks
1103
# and need to populate it.
1104
if (self._fallback_repositories and
1105
len(self._real_repository._fallback_repositories) !=
1106
len(self._fallback_repositories)):
1107
if len(self._real_repository._fallback_repositories):
1108
raise AssertionError(
1109
"cannot cleanly remove existing _fallback_repositories")
903
# If the _real_repository has _fallback_repositories, clear them out,
904
# because we want it to have the same set as this repository. This is
905
# reasonable to do because the fallbacks we clear here are from a
906
# "real" branch, and we're about to replace them with the equivalents
907
# from a RemoteBranch.
908
self._real_repository._fallback_repositories = []
1110
909
for fb in self._fallback_repositories:
1111
910
self._real_repository.add_fallback_repository(fb)
1112
911
if self._lock_mode == 'w':
1241
1035
# We need to accumulate additional repositories here, to pass them in
1242
1036
# on various RPC's.
1244
if self.is_locked():
1245
# We will call fallback.unlock() when we transition to the unlocked
1246
# state, so always add a lock here. If a caller passes us a locked
1247
# repository, they are responsible for unlocking it later.
1248
repository.lock_read()
1249
self._check_fallback_repository(repository)
1250
1038
self._fallback_repositories.append(repository)
1251
1039
# If self._real_repository was parameterised already (e.g. because a
1252
1040
# _real_branch had its get_stacked_on_url method called), then the
1253
1041
# repository to be added may already be in the _real_repositories list.
1254
1042
if self._real_repository is not None:
1255
fallback_locations = [repo.user_url for repo in
1256
self._real_repository._fallback_repositories]
1257
if repository.user_url not in fallback_locations:
1043
if repository not in self._real_repository._fallback_repositories:
1258
1044
self._real_repository.add_fallback_repository(repository)
1260
def _check_fallback_repository(self, repository):
1261
"""Check that this repository can fallback to repository safely.
1263
Raise an error if not.
1265
:param repository: A repository to fallback to.
1267
return _mod_repository.InterRepository._assert_same_model(
1046
# They are also seen by the fallback repository. If it doesn't
1047
# exist yet they'll be added then. This implicitly copies them.
1270
1050
def add_inventory(self, revid, inv, parents):
1271
1051
self._ensure_real()
1272
1052
return self._real_repository.add_inventory(revid, inv, parents)
1274
1054
def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1275
parents, basis_inv=None, propagate_caches=False):
1276
1056
self._ensure_real()
1277
1057
return self._real_repository.add_inventory_by_delta(basis_revision_id,
1278
delta, new_revision_id, parents, basis_inv=basis_inv,
1279
propagate_caches=propagate_caches)
1058
delta, new_revision_id, parents)
1281
1060
def add_revision(self, rev_id, rev, inv=None, config=None):
1282
1061
self._ensure_real()
1453
1229
# TODO: Manage this incrementally to avoid covering the same path
1454
1230
# repeatedly. (The server will have to on each request, but the less
1455
1231
# work done the better).
1457
# Negative caching notes:
1458
# new server sends missing when a request including the revid
1459
# 'include-missing:' is present in the request.
1460
# missing keys are serialised as missing:X, and we then call
1461
# provider.note_missing(X) for-all X
1462
1232
parents_map = self._unstacked_provider.get_cached_map()
1463
1233
if parents_map is None:
1464
1234
# Repository is not locked, so there's no cache.
1465
1235
parents_map = {}
1466
# start_set is all the keys in the cache
1467
1236
start_set = set(parents_map)
1468
# result set is all the references to keys in the cache
1469
1237
result_parents = set()
1470
1238
for parents in parents_map.itervalues():
1471
1239
result_parents.update(parents)
1472
1240
stop_keys = result_parents.difference(start_set)
1473
# We don't need to send ghosts back to the server as a position to
1475
stop_keys.difference_update(self._unstacked_provider.missing_keys)
1476
key_count = len(parents_map)
1477
if (NULL_REVISION in result_parents
1478
and NULL_REVISION in self._unstacked_provider.missing_keys):
1479
# If we pruned NULL_REVISION from the stop_keys because it's also
1480
# in our cache of "missing" keys we need to increment our key count
1481
# by 1, because the reconsitituted SearchResult on the server will
1482
# still consider NULL_REVISION to be an included key.
1484
1241
included_keys = start_set.intersection(result_parents)
1485
1242
start_set.difference_update(included_keys)
1486
recipe = ('manual', start_set, stop_keys, key_count)
1243
recipe = ('manual', start_set, stop_keys, len(parents_map))
1487
1244
body = self._serialise_search_recipe(recipe)
1488
1245
path = self.bzrdir._path_for_remote_call(self._client)
1489
1246
for key in keys:
1788
1547
def insert_stream(self, stream, src_format, resume_tokens):
1789
1548
target = self.target_repo
1790
target._unstacked_provider.missing_keys.clear()
1791
candidate_calls = [('Repository.insert_stream_1.19', (1, 19))]
1792
1549
if target._lock_token:
1793
candidate_calls.append(('Repository.insert_stream_locked', (1, 14)))
1794
lock_args = (target._lock_token or '',)
1550
verb = 'Repository.insert_stream_locked'
1551
extra_args = (target._lock_token or '',)
1552
required_version = (1, 14)
1796
candidate_calls.append(('Repository.insert_stream', (1, 13)))
1554
verb = 'Repository.insert_stream'
1556
required_version = (1, 13)
1798
1557
client = target._client
1799
1558
medium = client._medium
1559
if medium._is_remote_before(required_version):
1560
# No possible way this can work.
1561
return self._insert_real(stream, src_format, resume_tokens)
1800
1562
path = target.bzrdir._path_for_remote_call(client)
1801
# Probe for the verb to use with an empty stream before sending the
1802
# real stream to it. We do this both to avoid the risk of sending a
1803
# large request that is then rejected, and because we don't want to
1804
# implement a way to buffer, rewind, or restart the stream.
1806
for verb, required_version in candidate_calls:
1807
if medium._is_remote_before(required_version):
1810
# We've already done the probing (and set _is_remote_before) on
1811
# a previous insert.
1563
if not resume_tokens:
1564
# XXX: Ugly but important for correctness, *will* be fixed during
1565
# 1.13 cycle. Pushing a stream that is interrupted results in a
1566
# fallback to the _real_repositories sink *with a partial stream*.
1567
# Thats bad because we insert less data than bzr expected. To avoid
1568
# this we do a trial push to make sure the verb is accessible, and
1569
# do not fallback when actually pushing the stream. A cleanup patch
1570
# is going to look at rewinding/restarting the stream/partial
1814
1572
byte_stream = smart_repo._stream_to_byte_stream([], src_format)
1816
1574
response = client.call_with_body_stream(
1817
(verb, path, '') + lock_args, byte_stream)
1575
(verb, path, '') + extra_args, byte_stream)
1818
1576
except errors.UnknownSmartMethod:
1819
1577
medium._remember_remote_is_before(required_version)
1825
return self._insert_real(stream, src_format, resume_tokens)
1826
self._last_inv_record = None
1827
self._last_substream = None
1828
if required_version < (1, 19):
1829
# Remote side doesn't support inventory deltas. Wrap the stream to
1830
# make sure we don't send any. If the stream contains inventory
1831
# deltas we'll interrupt the smart insert_stream request and
1833
stream = self._stop_stream_if_inventory_delta(stream)
1578
return self._insert_real(stream, src_format, resume_tokens)
1834
1579
byte_stream = smart_repo._stream_to_byte_stream(
1835
1580
stream, src_format)
1836
1581
resume_tokens = ' '.join(resume_tokens)
1837
1582
response = client.call_with_body_stream(
1838
(verb, path, resume_tokens) + lock_args, byte_stream)
1583
(verb, path, resume_tokens) + extra_args, byte_stream)
1839
1584
if response[0][0] not in ('ok', 'missing-basis'):
1840
1585
raise errors.UnexpectedSmartServerResponse(response)
1841
if self._last_substream is not None:
1842
# The stream included an inventory-delta record, but the remote
1843
# side isn't new enough to support them. So we need to send the
1844
# rest of the stream via VFS.
1845
self.target_repo.refresh_data()
1846
return self._resume_stream_with_vfs(response, src_format)
1847
1586
if response[0][0] == 'missing-basis':
1848
1587
tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1849
1588
resume_tokens = tokens
1850
return resume_tokens, set(missing_keys)
1589
return resume_tokens, missing_keys
1852
1591
self.target_repo.refresh_data()
1853
1592
return [], set()
1855
def _resume_stream_with_vfs(self, response, src_format):
1856
"""Resume sending a stream via VFS, first resending the record and
1857
substream that couldn't be sent via an insert_stream verb.
1859
if response[0][0] == 'missing-basis':
1860
tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1861
# Ignore missing_keys, we haven't finished inserting yet
1864
def resume_substream():
1865
# Yield the substream that was interrupted.
1866
for record in self._last_substream:
1868
self._last_substream = None
1869
def resume_stream():
1870
# Finish sending the interrupted substream
1871
yield ('inventory-deltas', resume_substream())
1872
# Then simply continue sending the rest of the stream.
1873
for substream_kind, substream in self._last_stream:
1874
yield substream_kind, substream
1875
return self._insert_real(resume_stream(), src_format, tokens)
1877
def _stop_stream_if_inventory_delta(self, stream):
1878
"""Normally this just lets the original stream pass-through unchanged.
1880
However if any 'inventory-deltas' substream occurs it will stop
1881
streaming, and store the interrupted substream and stream in
1882
self._last_substream and self._last_stream so that the stream can be
1883
resumed by _resume_stream_with_vfs.
1886
stream_iter = iter(stream)
1887
for substream_kind, substream in stream_iter:
1888
if substream_kind == 'inventory-deltas':
1889
self._last_substream = substream
1890
self._last_stream = stream_iter
1893
yield substream_kind, substream
1896
1595
class RemoteStreamSource(repository.StreamSource):
1897
1596
"""Stream data from a remote server."""
1953
1636
return self._real_stream(repo, search)
1954
1637
client = repo._client
1955
1638
medium = client._medium
1639
if medium._is_remote_before((1, 13)):
1640
# streaming was added in 1.13
1641
return self._real_stream(repo, search)
1956
1642
path = repo.bzrdir._path_for_remote_call(client)
1957
search_bytes = repo._serialise_search_result(search)
1958
args = (path, self.to_format.network_name())
1960
('Repository.get_stream_1.19', (1, 19)),
1961
('Repository.get_stream', (1, 13))]
1963
for verb, version in candidate_verbs:
1964
if medium._is_remote_before(version):
1967
response = repo._call_with_body_bytes_expecting_body(
1968
verb, args, search_bytes)
1969
except errors.UnknownSmartMethod:
1970
medium._remember_remote_is_before(version)
1972
response_tuple, response_handler = response
1644
search_bytes = repo._serialise_search_result(search)
1645
response = repo._call_with_body_bytes_expecting_body(
1646
'Repository.get_stream',
1647
(path, self.to_format.network_name()), search_bytes)
1648
response_tuple, response_handler = response
1649
except errors.UnknownSmartMethod:
1650
medium._remember_remote_is_before((1,13))
1976
1651
return self._real_stream(repo, search)
1977
1652
if response_tuple[0] != 'ok':
1978
1653
raise errors.UnexpectedSmartServerResponse(response_tuple)
2059
1733
self._network_name)
2061
1735
def get_format_description(self):
2063
return 'Remote: ' + self._custom_format.get_format_description()
1736
return 'Remote BZR Branch'
2065
1738
def network_name(self):
2066
1739
return self._network_name
2068
def open(self, a_bzrdir, name=None, ignore_fallbacks=False):
2069
return a_bzrdir.open_branch(name=name,
2070
ignore_fallbacks=ignore_fallbacks)
1741
def open(self, a_bzrdir):
1742
return a_bzrdir.open_branch()
2072
def _vfs_initialize(self, a_bzrdir, name):
1744
def _vfs_initialize(self, a_bzrdir):
2073
1745
# Initialisation when using a local bzrdir object, or a non-vfs init
2074
1746
# method is not available on the server.
2075
1747
# self._custom_format is always set - the start of initialize ensures
2077
1749
if isinstance(a_bzrdir, RemoteBzrDir):
2078
1750
a_bzrdir._ensure_real()
2079
result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
1751
result = self._custom_format.initialize(a_bzrdir._real_bzrdir)
2082
1753
# We assume the bzrdir is parameterised; it may not be.
2083
result = self._custom_format.initialize(a_bzrdir, name)
1754
result = self._custom_format.initialize(a_bzrdir)
2084
1755
if (isinstance(a_bzrdir, RemoteBzrDir) and
2085
1756
not isinstance(result, RemoteBranch)):
2086
result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
1757
result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result)
2090
def initialize(self, a_bzrdir, name=None):
1760
def initialize(self, a_bzrdir):
2091
1761
# 1) get the network name to use.
2092
1762
if self._custom_format:
2093
1763
network_name = self._custom_format.network_name()
2099
1769
network_name = reference_format.network_name()
2100
1770
# Being asked to create on a non RemoteBzrDir:
2101
1771
if not isinstance(a_bzrdir, RemoteBzrDir):
2102
return self._vfs_initialize(a_bzrdir, name=name)
1772
return self._vfs_initialize(a_bzrdir)
2103
1773
medium = a_bzrdir._client._medium
2104
1774
if medium._is_remote_before((1, 13)):
2105
return self._vfs_initialize(a_bzrdir, name=name)
1775
return self._vfs_initialize(a_bzrdir)
2106
1776
# Creating on a remote bzr dir.
2107
1777
# 2) try direct creation via RPC
2108
1778
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2109
if name is not None:
2110
# XXX JRV20100304: Support creating colocated branches
2111
raise errors.NoColocatedBranchSupport(self)
2112
1779
verb = 'BzrDir.create_branch'
2114
1781
response = a_bzrdir._call(verb, path, network_name)
2115
1782
except errors.UnknownSmartMethod:
2116
1783
# Fallback - use vfs methods
2117
1784
medium._remember_remote_is_before((1, 13))
2118
return self._vfs_initialize(a_bzrdir, name=name)
1785
return self._vfs_initialize(a_bzrdir)
2119
1786
if response[0] != 'ok':
2120
1787
raise errors.UnexpectedSmartServerResponse(response)
2121
1788
# Turn the response into a RemoteRepository object.
2374
2027
return self._vfs_get_tags_bytes()
2375
2028
return response[0]
2377
def _vfs_set_tags_bytes(self, bytes):
2379
return self._real_branch._set_tags_bytes(bytes)
2381
def _set_tags_bytes(self, bytes):
2382
medium = self._client._medium
2383
if medium._is_remote_before((1, 18)):
2384
self._vfs_set_tags_bytes(bytes)
2388
self._remote_path(), self._lock_token, self._repo_lock_token)
2389
response = self._call_with_body_bytes(
2390
'Branch.set_tags_bytes', args, bytes)
2391
except errors.UnknownSmartMethod:
2392
medium._remember_remote_is_before((1, 18))
2393
self._vfs_set_tags_bytes(bytes)
2395
2030
def lock_read(self):
2396
"""Lock the branch for read operations.
2398
:return: A bzrlib.lock.LogicalLockResult.
2400
2031
self.repository.lock_read()
2401
2032
if not self._lock_mode:
2402
self._note_lock('r')
2403
2033
self._lock_mode = 'r'
2404
2034
self._lock_count = 1
2405
2035
if self._real_branch is not None:
2406
2036
self._real_branch.lock_read()
2408
2038
self._lock_count += 1
2409
return lock.LogicalLockResult(self.unlock)
2411
2040
def _remote_lock_write(self, token):
2412
2041
if token is None:
2413
2042
branch_token = repo_token = ''
2415
2044
branch_token = token
2416
repo_token = self.repository.lock_write().repository_token
2045
repo_token = self.repository.lock_write()
2417
2046
self.repository.unlock()
2418
2047
err_context = {'token': token}
2419
2048
response = self._call(
2634
2244
self._ensure_real()
2635
2245
return self._real_branch._get_parent_location()
2247
def set_parent(self, url):
2249
return self._real_branch.set_parent(url)
2637
2251
def _set_parent_location(self, url):
2638
medium = self._client._medium
2639
if medium._is_remote_before((1, 15)):
2640
return self._vfs_set_parent_location(url)
2642
call_url = url or ''
2643
if type(call_url) is not str:
2644
raise AssertionError('url must be a str or None (%s)' % url)
2645
response = self._call('Branch.set_parent_location',
2646
self._remote_path(), self._lock_token, self._repo_lock_token,
2648
except errors.UnknownSmartMethod:
2649
medium._remember_remote_is_before((1, 15))
2650
return self._vfs_set_parent_location(url)
2652
raise errors.UnexpectedSmartServerResponse(response)
2654
def _vfs_set_parent_location(self, url):
2252
# Used by tests, to poke bad urls into branch configurations
2254
self.set_parent(url)
2257
return self._real_branch._set_parent_location(url)
2259
def set_stacked_on_url(self, stacked_location):
2260
"""Set the URL this branch is stacked against.
2262
:raises UnstackableBranchFormat: If the branch does not support
2264
:raises UnstackableRepositoryFormat: If the repository does not support
2655
2267
self._ensure_real()
2656
return self._real_branch._set_parent_location(url)
2268
return self._real_branch.set_stacked_on_url(stacked_location)
2658
2270
@needs_write_lock
2659
2271
def pull(self, source, overwrite=False, stop_revision=None,
2727
2339
return self._real_branch.set_push_location(location)
2730
class RemoteConfig(object):
2731
"""A Config that reads and writes from smart verbs.
2733
It is a low-level object that considers config data to be name/value pairs
2734
that may be associated with a section. Assigning meaning to the these
2735
values is done at higher levels like bzrlib.config.TreeConfig.
2738
def get_option(self, name, section=None, default=None):
2739
"""Return the value associated with a named option.
2741
:param name: The name of the value
2742
:param section: The section the option is in (if any)
2743
:param default: The value to return if the value is not set
2744
:return: The value or default value
2747
configobj = self._get_configobj()
2749
section_obj = configobj
2752
section_obj = configobj[section]
2755
return section_obj.get(name, default)
2756
except errors.UnknownSmartMethod:
2757
return self._vfs_get_option(name, section, default)
2759
def _response_to_configobj(self, response):
2760
if len(response[0]) and response[0][0] != 'ok':
2761
raise errors.UnexpectedSmartServerResponse(response)
2762
lines = response[1].read_body_bytes().splitlines()
2763
return config.ConfigObj(lines, encoding='utf-8')
2766
class RemoteBranchConfig(RemoteConfig):
2767
"""A RemoteConfig for Branches."""
2769
def __init__(self, branch):
2770
self._branch = branch
2772
def _get_configobj(self):
2773
path = self._branch._remote_path()
2774
response = self._branch._client.call_expecting_body(
2775
'Branch.get_config_file', path)
2776
return self._response_to_configobj(response)
2778
def set_option(self, value, name, section=None):
2779
"""Set the value associated with a named option.
2781
:param value: The value to set
2782
:param name: The name of the value to set
2783
:param section: The section the option is in (if any)
2785
medium = self._branch._client._medium
2786
if medium._is_remote_before((1, 14)):
2787
return self._vfs_set_option(value, name, section)
2789
path = self._branch._remote_path()
2790
response = self._branch._client.call('Branch.set_config_option',
2791
path, self._branch._lock_token, self._branch._repo_lock_token,
2792
value.encode('utf8'), name, section or '')
2793
except errors.UnknownSmartMethod:
2794
medium._remember_remote_is_before((1, 14))
2795
return self._vfs_set_option(value, name, section)
2797
raise errors.UnexpectedSmartServerResponse(response)
2799
def _real_object(self):
2800
self._branch._ensure_real()
2801
return self._branch._real_branch
2803
def _vfs_set_option(self, value, name, section=None):
2804
return self._real_object()._get_config().set_option(
2805
value, name, section)
2808
class RemoteBzrDirConfig(RemoteConfig):
2809
"""A RemoteConfig for BzrDirs."""
2811
def __init__(self, bzrdir):
2812
self._bzrdir = bzrdir
2814
def _get_configobj(self):
2815
medium = self._bzrdir._client._medium
2816
verb = 'BzrDir.get_config_file'
2817
if medium._is_remote_before((1, 15)):
2818
raise errors.UnknownSmartMethod(verb)
2819
path = self._bzrdir._path_for_remote_call(self._bzrdir._client)
2820
response = self._bzrdir._call_expecting_body(
2822
return self._response_to_configobj(response)
2824
def _vfs_get_option(self, name, section, default):
2825
return self._real_object()._get_config().get_option(
2826
name, section, default)
2828
def set_option(self, value, name, section=None):
2829
"""Set the value associated with a named option.
2831
:param value: The value to set
2832
:param name: The name of the value to set
2833
:param section: The section the option is in (if any)
2835
return self._real_object()._get_config().set_option(
2836
value, name, section)
2838
def _real_object(self):
2839
self._bzrdir._ensure_real()
2840
return self._bzrdir._real_bzrdir
2844
2342
def _extract_tar(tar, to_dir):
2845
2343
"""Extract all the contents of a tarfile object.
2884
2382
'Missing key %r in context %r', key_err.args[0], context)
2887
if err.error_verb == 'IncompatibleRepositories':
2888
raise errors.IncompatibleRepositories(err.error_args[0],
2889
err.error_args[1], err.error_args[2])
2890
elif err.error_verb == 'NoSuchRevision':
2385
if err.error_verb == 'NoSuchRevision':
2891
2386
raise NoSuchRevision(find('branch'), err.error_args[0])
2892
2387
elif err.error_verb == 'nosuchrevision':
2893
2388
raise NoSuchRevision(find('repository'), err.error_args[0])
2894
elif err.error_verb == 'nobranch':
2895
if len(err.error_args) >= 1:
2896
extra = err.error_args[0]
2899
raise errors.NotBranchError(path=find('bzrdir').root_transport.base,
2389
elif err.error_tuple == ('nobranch',):
2390
raise errors.NotBranchError(path=find('bzrdir').root_transport.base)
2901
2391
elif err.error_verb == 'norepository':
2902
2392
raise errors.NoRepositoryPresent(find('bzrdir'))
2903
2393
elif err.error_verb == 'LockContention':
added
removed
bzrlib/remote.py
