13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
# TODO: At some point, handle upgrades by just passing the whole request
18
# across to run on the server.
19
22
from bzrlib import (
31
repository as _mod_repository,
33
revision as _mod_revision,
37
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
35
from bzrlib.branch import BranchReferenceFormat
38
36
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
39
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
37
from bzrlib.decorators import needs_read_lock, needs_write_lock
40
38
from bzrlib.errors import (
42
40
SmartProtocolError,
113
104
self._client = client._SmartClient(medium)
115
106
self._client = _client
122
return '%s(%r)' % (self.__class__.__name__, self._client)
124
def _probe_bzrdir(self):
125
medium = self._client._medium
126
109
path = self._path_for_remote_call(self._client)
127
if medium._is_remote_before((2, 1)):
131
self._rpc_open_2_1(path)
133
except errors.UnknownSmartMethod:
134
medium._remember_remote_is_before((2, 1))
137
def _rpc_open_2_1(self, path):
138
response = self._call('BzrDir.open_2.1', path)
139
if response == ('no',):
140
raise errors.NotBranchError(path=self.root_transport.base)
141
elif response[0] == 'yes':
142
if response[1] == 'yes':
143
self._has_working_tree = True
144
elif response[1] == 'no':
145
self._has_working_tree = False
147
raise errors.UnexpectedSmartServerResponse(response)
149
raise errors.UnexpectedSmartServerResponse(response)
151
def _rpc_open(self, path):
152
110
response = self._call('BzrDir.open', path)
153
111
if response not in [('yes',), ('no',)]:
154
112
raise errors.UnexpectedSmartServerResponse(response)
155
113
if response == ('no',):
156
raise errors.NotBranchError(path=self.root_transport.base)
114
raise errors.NotBranchError(path=transport.base)
158
116
def _ensure_real(self):
159
117
"""Ensure that there is a _real_bzrdir set.
265
208
self._next_open_branch_result = result
268
def destroy_branch(self, name=None):
211
def destroy_branch(self):
269
212
"""See BzrDir.destroy_branch"""
270
213
self._ensure_real()
271
self._real_bzrdir.destroy_branch(name=name)
214
self._real_bzrdir.destroy_branch()
272
215
self._next_open_branch_result = None
274
217
def create_workingtree(self, revision_id=None, from_branch=None):
275
218
raise errors.NotLocalUrl(self.transport.base)
277
def find_branch_format(self, name=None):
220
def find_branch_format(self):
278
221
"""Find the branch 'format' for this bzrdir.
280
223
This might be a synthetic object for e.g. RemoteBranch and SVN.
282
b = self.open_branch(name=name)
225
b = self.open_branch()
285
def get_branch_reference(self, name=None):
228
def get_branch_reference(self):
286
229
"""See BzrDir.get_branch_reference()."""
288
# XXX JRV20100304: Support opening colocated branches
289
raise errors.NoColocatedBranchSupport(self)
290
230
response = self._get_branch_reference()
291
231
if response[0] == 'ref':
292
232
return response[1]
296
236
def _get_branch_reference(self):
297
237
path = self._path_for_remote_call(self._client)
298
238
medium = self._client._medium
300
('BzrDir.open_branchV3', (2, 1)),
301
('BzrDir.open_branchV2', (1, 13)),
302
('BzrDir.open_branch', None),
304
for verb, required_version in candidate_calls:
305
if required_version and medium._is_remote_before(required_version):
239
if not medium._is_remote_before((1, 13)):
308
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)
309
245
except errors.UnknownSmartMethod:
310
if required_version is None:
312
medium._remember_remote_is_before(required_version)
315
if verb == 'BzrDir.open_branch':
316
if response[0] != 'ok':
317
raise errors.UnexpectedSmartServerResponse(response)
318
if response[1] != '':
319
return ('ref', response[1])
321
return ('branch', '')
322
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':
323
249
raise errors.UnexpectedSmartServerResponse(response)
250
if response[1] != '':
251
return ('ref', response[1])
253
return ('branch', '')
326
def _get_tree_branch(self, name=None):
255
def _get_tree_branch(self):
327
256
"""See BzrDir._get_tree_branch()."""
328
return None, self.open_branch(name=name)
257
return None, self.open_branch()
330
def open_branch(self, name=None, unsupported=False,
331
ignore_fallbacks=False):
259
def open_branch(self, _unsupported=False):
333
261
raise NotImplementedError('unsupported flag support not implemented yet.')
334
262
if self._next_open_branch_result is not None:
335
263
# See create_branch for details.
757
639
self._ensure_real()
758
640
return self._real_repository.suspend_write_group()
760
def get_missing_parent_inventories(self, check_for_missing_texts=True):
762
return self._real_repository.get_missing_parent_inventories(
763
check_for_missing_texts=check_for_missing_texts)
765
def _get_rev_id_for_revno_vfs(self, revno, known_pair):
767
return self._real_repository.get_rev_id_for_revno(
770
def get_rev_id_for_revno(self, revno, known_pair):
771
"""See Repository.get_rev_id_for_revno."""
772
path = self.bzrdir._path_for_remote_call(self._client)
774
if self._client._medium._is_remote_before((1, 17)):
775
return self._get_rev_id_for_revno_vfs(revno, known_pair)
776
response = self._call(
777
'Repository.get_rev_id_for_revno', path, revno, known_pair)
778
except errors.UnknownSmartMethod:
779
self._client._medium._remember_remote_is_before((1, 17))
780
return self._get_rev_id_for_revno_vfs(revno, known_pair)
781
if response[0] == 'ok':
782
return True, response[1]
783
elif response[0] == 'history-incomplete':
784
known_pair = response[1:3]
785
for fallback in self._fallback_repositories:
786
found, result = fallback.get_rev_id_for_revno(revno, known_pair)
791
# Not found in any fallbacks
792
return False, known_pair
794
raise errors.UnexpectedSmartServerResponse(response)
796
642
def _ensure_real(self):
797
643
"""Ensure that there is a _real_repository set.
877
723
"""Return a source for streaming from this repository."""
878
724
return RemoteStreamSource(self, to_format)
881
726
def has_revision(self, revision_id):
882
"""True if this repository has a copy of the revision."""
883
# Copy of bzrlib.repository.Repository.has_revision
884
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):
887
742
def has_revisions(self, revision_ids):
888
"""Probe to find out the presence of multiple revisions.
890
:param revision_ids: An iterable of revision_ids.
891
:return: A set of the revision_ids that were present.
893
# Copy of bzrlib.repository.Repository.has_revisions
894
parent_map = self.get_parent_map(revision_ids)
895
result = set(parent_map)
896
if _mod_revision.NULL_REVISION in revision_ids:
897
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)
900
def _has_same_fallbacks(self, other_repo):
901
"""Returns true if the repositories have the same fallbacks."""
902
# XXX: copied from Repository; it should be unified into a base class
903
# <https://bugs.launchpad.net/bzr/+bug/401622>
904
my_fb = self._fallback_repositories
905
other_fb = other_repo._fallback_repositories
906
if len(my_fb) != len(other_fb):
908
for f, g in zip(my_fb, other_fb):
909
if not f.has_same_location(g):
913
752
def has_same_location(self, other):
914
# TODO: Move to RepositoryBase and unify with the regular Repository
915
# one; unfortunately the tests rely on slightly different behaviour at
916
# present -- mbp 20090710
917
753
return (self.__class__ is other.__class__ and
918
754
self.bzrdir.transport.base == other.bzrdir.transport.base)
1091
900
if isinstance(repository, RemoteRepository):
1092
901
raise AssertionError()
1093
902
self._real_repository = repository
1094
# three code paths happen here:
1095
# 1) old servers, RemoteBranch.open() calls _ensure_real before setting
1096
# up stacking. In this case self._fallback_repositories is [], and the
1097
# real repo is already setup. Preserve the real repo and
1098
# RemoteRepository.add_fallback_repository will avoid adding
1100
# 2) new servers, RemoteBranch.open() sets up stacking, and when
1101
# ensure_real is triggered from a branch, the real repository to
1102
# set already has a matching list with separate instances, but
1103
# as they are also RemoteRepositories we don't worry about making the
1104
# lists be identical.
1105
# 3) new servers, RemoteRepository.ensure_real is triggered before
1106
# RemoteBranch.ensure real, in this case we get a repo with no fallbacks
1107
# and need to populate it.
1108
if (self._fallback_repositories and
1109
len(self._real_repository._fallback_repositories) !=
1110
len(self._fallback_repositories)):
1111
if len(self._real_repository._fallback_repositories):
1112
raise AssertionError(
1113
"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 = []
1114
909
for fb in self._fallback_repositories:
1115
910
self._real_repository.add_fallback_repository(fb)
1116
911
if self._lock_mode == 'w':
1245
1035
# We need to accumulate additional repositories here, to pass them in
1246
1036
# on various RPC's.
1248
if self.is_locked():
1249
# We will call fallback.unlock() when we transition to the unlocked
1250
# state, so always add a lock here. If a caller passes us a locked
1251
# repository, they are responsible for unlocking it later.
1252
repository.lock_read()
1253
self._check_fallback_repository(repository)
1254
1038
self._fallback_repositories.append(repository)
1255
1039
# If self._real_repository was parameterised already (e.g. because a
1256
1040
# _real_branch had its get_stacked_on_url method called), then the
1257
1041
# repository to be added may already be in the _real_repositories list.
1258
1042
if self._real_repository is not None:
1259
fallback_locations = [repo.user_url for repo in
1260
self._real_repository._fallback_repositories]
1261
if repository.user_url not in fallback_locations:
1043
if repository not in self._real_repository._fallback_repositories:
1262
1044
self._real_repository.add_fallback_repository(repository)
1264
def _check_fallback_repository(self, repository):
1265
"""Check that this repository can fallback to repository safely.
1267
Raise an error if not.
1269
:param repository: A repository to fallback to.
1271
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.
1274
1050
def add_inventory(self, revid, inv, parents):
1275
1051
self._ensure_real()
1276
1052
return self._real_repository.add_inventory(revid, inv, parents)
1278
1054
def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1279
parents, basis_inv=None, propagate_caches=False):
1280
1056
self._ensure_real()
1281
1057
return self._real_repository.add_inventory_by_delta(basis_revision_id,
1282
delta, new_revision_id, parents, basis_inv=basis_inv,
1283
propagate_caches=propagate_caches)
1058
delta, new_revision_id, parents)
1285
1060
def add_revision(self, rev_id, rev, inv=None, config=None):
1286
1061
self._ensure_real()
1457
1229
# TODO: Manage this incrementally to avoid covering the same path
1458
1230
# repeatedly. (The server will have to on each request, but the less
1459
1231
# work done the better).
1461
# Negative caching notes:
1462
# new server sends missing when a request including the revid
1463
# 'include-missing:' is present in the request.
1464
# missing keys are serialised as missing:X, and we then call
1465
# provider.note_missing(X) for-all X
1466
1232
parents_map = self._unstacked_provider.get_cached_map()
1467
1233
if parents_map is None:
1468
1234
# Repository is not locked, so there's no cache.
1469
1235
parents_map = {}
1470
# start_set is all the keys in the cache
1471
1236
start_set = set(parents_map)
1472
# result set is all the references to keys in the cache
1473
1237
result_parents = set()
1474
1238
for parents in parents_map.itervalues():
1475
1239
result_parents.update(parents)
1476
1240
stop_keys = result_parents.difference(start_set)
1477
# We don't need to send ghosts back to the server as a position to
1479
stop_keys.difference_update(self._unstacked_provider.missing_keys)
1480
key_count = len(parents_map)
1481
if (NULL_REVISION in result_parents
1482
and NULL_REVISION in self._unstacked_provider.missing_keys):
1483
# If we pruned NULL_REVISION from the stop_keys because it's also
1484
# in our cache of "missing" keys we need to increment our key count
1485
# by 1, because the reconsitituted SearchResult on the server will
1486
# still consider NULL_REVISION to be an included key.
1488
1241
included_keys = start_set.intersection(result_parents)
1489
1242
start_set.difference_update(included_keys)
1490
recipe = ('manual', start_set, stop_keys, key_count)
1243
recipe = ('manual', start_set, stop_keys, len(parents_map))
1491
1244
body = self._serialise_search_recipe(recipe)
1492
1245
path = self.bzrdir._path_for_remote_call(self._client)
1493
1246
for key in keys:
1792
1545
def insert_stream(self, stream, src_format, resume_tokens):
1793
1546
target = self.target_repo
1794
target._unstacked_provider.missing_keys.clear()
1795
candidate_calls = [('Repository.insert_stream_1.19', (1, 19))]
1796
1547
if target._lock_token:
1797
candidate_calls.append(('Repository.insert_stream_locked', (1, 14)))
1798
lock_args = (target._lock_token or '',)
1548
verb = 'Repository.insert_stream_locked'
1549
extra_args = (target._lock_token or '',)
1550
required_version = (1, 14)
1800
candidate_calls.append(('Repository.insert_stream', (1, 13)))
1552
verb = 'Repository.insert_stream'
1554
required_version = (1, 13)
1802
1555
client = target._client
1803
1556
medium = client._medium
1557
if medium._is_remote_before(required_version):
1558
# No possible way this can work.
1559
return self._insert_real(stream, src_format, resume_tokens)
1804
1560
path = target.bzrdir._path_for_remote_call(client)
1805
# Probe for the verb to use with an empty stream before sending the
1806
# real stream to it. We do this both to avoid the risk of sending a
1807
# large request that is then rejected, and because we don't want to
1808
# implement a way to buffer, rewind, or restart the stream.
1810
for verb, required_version in candidate_calls:
1811
if medium._is_remote_before(required_version):
1814
# We've already done the probing (and set _is_remote_before) on
1815
# a previous insert.
1561
if not resume_tokens:
1562
# XXX: Ugly but important for correctness, *will* be fixed during
1563
# 1.13 cycle. Pushing a stream that is interrupted results in a
1564
# fallback to the _real_repositories sink *with a partial stream*.
1565
# Thats bad because we insert less data than bzr expected. To avoid
1566
# this we do a trial push to make sure the verb is accessible, and
1567
# do not fallback when actually pushing the stream. A cleanup patch
1568
# is going to look at rewinding/restarting the stream/partial
1818
1570
byte_stream = smart_repo._stream_to_byte_stream([], src_format)
1820
1572
response = client.call_with_body_stream(
1821
(verb, path, '') + lock_args, byte_stream)
1573
(verb, path, '') + extra_args, byte_stream)
1822
1574
except errors.UnknownSmartMethod:
1823
1575
medium._remember_remote_is_before(required_version)
1829
return self._insert_real(stream, src_format, resume_tokens)
1830
self._last_inv_record = None
1831
self._last_substream = None
1832
if required_version < (1, 19):
1833
# Remote side doesn't support inventory deltas. Wrap the stream to
1834
# make sure we don't send any. If the stream contains inventory
1835
# deltas we'll interrupt the smart insert_stream request and
1837
stream = self._stop_stream_if_inventory_delta(stream)
1576
return self._insert_real(stream, src_format, resume_tokens)
1838
1577
byte_stream = smart_repo._stream_to_byte_stream(
1839
1578
stream, src_format)
1840
1579
resume_tokens = ' '.join(resume_tokens)
1841
1580
response = client.call_with_body_stream(
1842
(verb, path, resume_tokens) + lock_args, byte_stream)
1581
(verb, path, resume_tokens) + extra_args, byte_stream)
1843
1582
if response[0][0] not in ('ok', 'missing-basis'):
1844
1583
raise errors.UnexpectedSmartServerResponse(response)
1845
if self._last_substream is not None:
1846
# The stream included an inventory-delta record, but the remote
1847
# side isn't new enough to support them. So we need to send the
1848
# rest of the stream via VFS.
1849
self.target_repo.refresh_data()
1850
return self._resume_stream_with_vfs(response, src_format)
1851
1584
if response[0][0] == 'missing-basis':
1852
1585
tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1853
1586
resume_tokens = tokens
1854
return resume_tokens, set(missing_keys)
1587
return resume_tokens, missing_keys
1856
1589
self.target_repo.refresh_data()
1857
1590
return [], set()
1859
def _resume_stream_with_vfs(self, response, src_format):
1860
"""Resume sending a stream via VFS, first resending the record and
1861
substream that couldn't be sent via an insert_stream verb.
1863
if response[0][0] == 'missing-basis':
1864
tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1865
# Ignore missing_keys, we haven't finished inserting yet
1868
def resume_substream():
1869
# Yield the substream that was interrupted.
1870
for record in self._last_substream:
1872
self._last_substream = None
1873
def resume_stream():
1874
# Finish sending the interrupted substream
1875
yield ('inventory-deltas', resume_substream())
1876
# Then simply continue sending the rest of the stream.
1877
for substream_kind, substream in self._last_stream:
1878
yield substream_kind, substream
1879
return self._insert_real(resume_stream(), src_format, tokens)
1881
def _stop_stream_if_inventory_delta(self, stream):
1882
"""Normally this just lets the original stream pass-through unchanged.
1884
However if any 'inventory-deltas' substream occurs it will stop
1885
streaming, and store the interrupted substream and stream in
1886
self._last_substream and self._last_stream so that the stream can be
1887
resumed by _resume_stream_with_vfs.
1890
stream_iter = iter(stream)
1891
for substream_kind, substream in stream_iter:
1892
if substream_kind == 'inventory-deltas':
1893
self._last_substream = substream
1894
self._last_stream = stream_iter
1897
yield substream_kind, substream
1900
1593
class RemoteStreamSource(repository.StreamSource):
1901
1594
"""Stream data from a remote server."""
1957
1634
return self._real_stream(repo, search)
1958
1635
client = repo._client
1959
1636
medium = client._medium
1637
if medium._is_remote_before((1, 13)):
1638
# streaming was added in 1.13
1639
return self._real_stream(repo, search)
1960
1640
path = repo.bzrdir._path_for_remote_call(client)
1961
search_bytes = repo._serialise_search_result(search)
1962
args = (path, self.to_format.network_name())
1964
('Repository.get_stream_1.19', (1, 19)),
1965
('Repository.get_stream', (1, 13))]
1967
for verb, version in candidate_verbs:
1968
if medium._is_remote_before(version):
1971
response = repo._call_with_body_bytes_expecting_body(
1972
verb, args, search_bytes)
1973
except errors.UnknownSmartMethod:
1974
medium._remember_remote_is_before(version)
1976
response_tuple, response_handler = response
1642
search_bytes = repo._serialise_search_result(search)
1643
response = repo._call_with_body_bytes_expecting_body(
1644
'Repository.get_stream',
1645
(path, self.to_format.network_name()), search_bytes)
1646
response_tuple, response_handler = response
1647
except errors.UnknownSmartMethod:
1648
medium._remember_remote_is_before((1,13))
1980
1649
return self._real_stream(repo, search)
1981
1650
if response_tuple[0] != 'ok':
1982
1651
raise errors.UnexpectedSmartServerResponse(response_tuple)
1983
1652
byte_stream = response_handler.read_streamed_body()
1984
src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
1985
self._record_counter)
1653
src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
1986
1654
if src_format.network_name() != repo._format.network_name():
1987
1655
raise AssertionError(
1988
1656
"Mismatched RemoteRepository and stream src %r, %r" % (
2064
1731
self._network_name)
2066
1733
def get_format_description(self):
2068
return 'Remote: ' + self._custom_format.get_format_description()
1734
return 'Remote BZR Branch'
2070
1736
def network_name(self):
2071
1737
return self._network_name
2073
def open(self, a_bzrdir, name=None, ignore_fallbacks=False):
2074
return a_bzrdir.open_branch(name=name,
2075
ignore_fallbacks=ignore_fallbacks)
1739
def open(self, a_bzrdir):
1740
return a_bzrdir.open_branch()
2077
def _vfs_initialize(self, a_bzrdir, name):
1742
def _vfs_initialize(self, a_bzrdir):
2078
1743
# Initialisation when using a local bzrdir object, or a non-vfs init
2079
1744
# method is not available on the server.
2080
1745
# self._custom_format is always set - the start of initialize ensures
2082
1747
if isinstance(a_bzrdir, RemoteBzrDir):
2083
1748
a_bzrdir._ensure_real()
2084
result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
1749
result = self._custom_format.initialize(a_bzrdir._real_bzrdir)
2087
1751
# We assume the bzrdir is parameterised; it may not be.
2088
result = self._custom_format.initialize(a_bzrdir, name)
1752
result = self._custom_format.initialize(a_bzrdir)
2089
1753
if (isinstance(a_bzrdir, RemoteBzrDir) and
2090
1754
not isinstance(result, RemoteBranch)):
2091
result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
1755
result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result)
2095
def initialize(self, a_bzrdir, name=None):
1758
def initialize(self, a_bzrdir):
2096
1759
# 1) get the network name to use.
2097
1760
if self._custom_format:
2098
1761
network_name = self._custom_format.network_name()
2104
1767
network_name = reference_format.network_name()
2105
1768
# Being asked to create on a non RemoteBzrDir:
2106
1769
if not isinstance(a_bzrdir, RemoteBzrDir):
2107
return self._vfs_initialize(a_bzrdir, name=name)
1770
return self._vfs_initialize(a_bzrdir)
2108
1771
medium = a_bzrdir._client._medium
2109
1772
if medium._is_remote_before((1, 13)):
2110
return self._vfs_initialize(a_bzrdir, name=name)
1773
return self._vfs_initialize(a_bzrdir)
2111
1774
# Creating on a remote bzr dir.
2112
1775
# 2) try direct creation via RPC
2113
1776
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2114
if name is not None:
2115
# XXX JRV20100304: Support creating colocated branches
2116
raise errors.NoColocatedBranchSupport(self)
2117
1777
verb = 'BzrDir.create_branch'
2119
1779
response = a_bzrdir._call(verb, path, network_name)
2120
1780
except errors.UnknownSmartMethod:
2121
1781
# Fallback - use vfs methods
2122
1782
medium._remember_remote_is_before((1, 13))
2123
return self._vfs_initialize(a_bzrdir, name=name)
1783
return self._vfs_initialize(a_bzrdir)
2124
1784
if response[0] != 'ok':
2125
1785
raise errors.UnexpectedSmartServerResponse(response)
2126
1786
# Turn the response into a RemoteRepository object.
2379
2025
return self._vfs_get_tags_bytes()
2380
2026
return response[0]
2382
def _vfs_set_tags_bytes(self, bytes):
2384
return self._real_branch._set_tags_bytes(bytes)
2386
def _set_tags_bytes(self, bytes):
2387
medium = self._client._medium
2388
if medium._is_remote_before((1, 18)):
2389
self._vfs_set_tags_bytes(bytes)
2393
self._remote_path(), self._lock_token, self._repo_lock_token)
2394
response = self._call_with_body_bytes(
2395
'Branch.set_tags_bytes', args, bytes)
2396
except errors.UnknownSmartMethod:
2397
medium._remember_remote_is_before((1, 18))
2398
self._vfs_set_tags_bytes(bytes)
2400
2028
def lock_read(self):
2401
"""Lock the branch for read operations.
2403
:return: A bzrlib.lock.LogicalLockResult.
2405
2029
self.repository.lock_read()
2406
2030
if not self._lock_mode:
2407
self._note_lock('r')
2408
2031
self._lock_mode = 'r'
2409
2032
self._lock_count = 1
2410
2033
if self._real_branch is not None:
2411
2034
self._real_branch.lock_read()
2413
2036
self._lock_count += 1
2414
return lock.LogicalLockResult(self.unlock)
2416
2038
def _remote_lock_write(self, token):
2417
2039
if token is None:
2418
2040
branch_token = repo_token = ''
2420
2042
branch_token = token
2421
repo_token = self.repository.lock_write().repository_token
2043
repo_token = self.repository.lock_write()
2422
2044
self.repository.unlock()
2423
2045
err_context = {'token': token}
2425
response = self._call(
2426
'Branch.lock_write', self._remote_path(), branch_token,
2427
repo_token or '', **err_context)
2428
except errors.LockContention, e:
2429
# The LockContention from the server doesn't have any
2430
# information about the lock_url. We re-raise LockContention
2431
# with valid lock_url.
2432
raise errors.LockContention('(remote lock)',
2433
self.repository.base.split('.bzr/')[0])
2046
response = self._call(
2047
'Branch.lock_write', self._remote_path(), branch_token,
2048
repo_token or '', **err_context)
2434
2049
if response[0] != 'ok':
2435
2050
raise errors.UnexpectedSmartServerResponse(response)
2436
2051
ok, branch_token, repo_token = response
2646
2242
self._ensure_real()
2647
2243
return self._real_branch._get_parent_location()
2245
def set_parent(self, url):
2247
return self._real_branch.set_parent(url)
2649
2249
def _set_parent_location(self, url):
2650
medium = self._client._medium
2651
if medium._is_remote_before((1, 15)):
2652
return self._vfs_set_parent_location(url)
2654
call_url = url or ''
2655
if type(call_url) is not str:
2656
raise AssertionError('url must be a str or None (%s)' % url)
2657
response = self._call('Branch.set_parent_location',
2658
self._remote_path(), self._lock_token, self._repo_lock_token,
2660
except errors.UnknownSmartMethod:
2661
medium._remember_remote_is_before((1, 15))
2662
return self._vfs_set_parent_location(url)
2664
raise errors.UnexpectedSmartServerResponse(response)
2666
def _vfs_set_parent_location(self, url):
2250
# Used by tests, to poke bad urls into branch configurations
2252
self.set_parent(url)
2255
return self._real_branch._set_parent_location(url)
2257
def set_stacked_on_url(self, stacked_location):
2258
"""Set the URL this branch is stacked against.
2260
:raises UnstackableBranchFormat: If the branch does not support
2262
:raises UnstackableRepositoryFormat: If the repository does not support
2667
2265
self._ensure_real()
2668
return self._real_branch._set_parent_location(url)
2266
return self._real_branch.set_stacked_on_url(stacked_location)
2670
2268
@needs_write_lock
2671
2269
def pull(self, source, overwrite=False, stop_revision=None,
2739
2337
return self._real_branch.set_push_location(location)
2742
class RemoteConfig(object):
2743
"""A Config that reads and writes from smart verbs.
2745
It is a low-level object that considers config data to be name/value pairs
2746
that may be associated with a section. Assigning meaning to the these
2747
values is done at higher levels like bzrlib.config.TreeConfig.
2750
def get_option(self, name, section=None, default=None):
2751
"""Return the value associated with a named option.
2753
:param name: The name of the value
2754
:param section: The section the option is in (if any)
2755
:param default: The value to return if the value is not set
2756
:return: The value or default value
2759
configobj = self._get_configobj()
2761
section_obj = configobj
2764
section_obj = configobj[section]
2767
return section_obj.get(name, default)
2768
except errors.UnknownSmartMethod:
2769
return self._vfs_get_option(name, section, default)
2771
def _response_to_configobj(self, response):
2772
if len(response[0]) and response[0][0] != 'ok':
2773
raise errors.UnexpectedSmartServerResponse(response)
2774
lines = response[1].read_body_bytes().splitlines()
2775
return config.ConfigObj(lines, encoding='utf-8')
2778
class RemoteBranchConfig(RemoteConfig):
2779
"""A RemoteConfig for Branches."""
2781
def __init__(self, branch):
2782
self._branch = branch
2784
def _get_configobj(self):
2785
path = self._branch._remote_path()
2786
response = self._branch._client.call_expecting_body(
2787
'Branch.get_config_file', path)
2788
return self._response_to_configobj(response)
2790
def set_option(self, value, name, section=None):
2791
"""Set the value associated with a named option.
2793
:param value: The value to set
2794
:param name: The name of the value to set
2795
:param section: The section the option is in (if any)
2797
medium = self._branch._client._medium
2798
if medium._is_remote_before((1, 14)):
2799
return self._vfs_set_option(value, name, section)
2800
if isinstance(value, dict):
2801
if medium._is_remote_before((2, 2)):
2802
return self._vfs_set_option(value, name, section)
2803
return self._set_config_option_dict(value, name, section)
2805
return self._set_config_option(value, name, section)
2807
def _set_config_option(self, value, name, section):
2809
path = self._branch._remote_path()
2810
response = self._branch._client.call('Branch.set_config_option',
2811
path, self._branch._lock_token, self._branch._repo_lock_token,
2812
value.encode('utf8'), name, section or '')
2813
except errors.UnknownSmartMethod:
2814
medium = self._branch._client._medium
2815
medium._remember_remote_is_before((1, 14))
2816
return self._vfs_set_option(value, name, section)
2818
raise errors.UnexpectedSmartServerResponse(response)
2820
def _serialize_option_dict(self, option_dict):
2822
for key, value in option_dict.items():
2823
if isinstance(key, unicode):
2824
key = key.encode('utf8')
2825
if isinstance(value, unicode):
2826
value = value.encode('utf8')
2827
utf8_dict[key] = value
2828
return bencode.bencode(utf8_dict)
2830
def _set_config_option_dict(self, value, name, section):
2832
path = self._branch._remote_path()
2833
serialised_dict = self._serialize_option_dict(value)
2834
response = self._branch._client.call(
2835
'Branch.set_config_option_dict',
2836
path, self._branch._lock_token, self._branch._repo_lock_token,
2837
serialised_dict, name, section or '')
2838
except errors.UnknownSmartMethod:
2839
medium = self._branch._client._medium
2840
medium._remember_remote_is_before((2, 2))
2841
return self._vfs_set_option(value, name, section)
2843
raise errors.UnexpectedSmartServerResponse(response)
2845
def _real_object(self):
2846
self._branch._ensure_real()
2847
return self._branch._real_branch
2849
def _vfs_set_option(self, value, name, section=None):
2850
return self._real_object()._get_config().set_option(
2851
value, name, section)
2854
class RemoteBzrDirConfig(RemoteConfig):
2855
"""A RemoteConfig for BzrDirs."""
2857
def __init__(self, bzrdir):
2858
self._bzrdir = bzrdir
2860
def _get_configobj(self):
2861
medium = self._bzrdir._client._medium
2862
verb = 'BzrDir.get_config_file'
2863
if medium._is_remote_before((1, 15)):
2864
raise errors.UnknownSmartMethod(verb)
2865
path = self._bzrdir._path_for_remote_call(self._bzrdir._client)
2866
response = self._bzrdir._call_expecting_body(
2868
return self._response_to_configobj(response)
2870
def _vfs_get_option(self, name, section, default):
2871
return self._real_object()._get_config().get_option(
2872
name, section, default)
2874
def set_option(self, value, name, section=None):
2875
"""Set the value associated with a named option.
2877
:param value: The value to set
2878
:param name: The name of the value to set
2879
:param section: The section the option is in (if any)
2881
return self._real_object()._get_config().set_option(
2882
value, name, section)
2884
def _real_object(self):
2885
self._bzrdir._ensure_real()
2886
return self._bzrdir._real_bzrdir
2890
2340
def _extract_tar(tar, to_dir):
2891
2341
"""Extract all the contents of a tarfile object.
added
removed
bzrlib/remote.py
