108
# Note that RemoteBzrDirProber lives in bzrlib.bzrdir so bzrlib.remote
109
# does not have to be imported unless a remote format is involved.
111
class RemoteBzrDirFormat(_mod_bzrdir.BzrDirMetaFormat1):
112
"""Format representing bzrdirs accessed via a smart server"""
114
supports_workingtrees = False
116
colocated_branches = False
119
_mod_bzrdir.BzrDirMetaFormat1.__init__(self)
120
# XXX: It's a bit ugly that the network name is here, because we'd
121
# like to believe that format objects are stateless or at least
122
# immutable, However, we do at least avoid mutating the name after
123
# it's returned. See <https://bugs.launchpad.net/bzr/+bug/504102>
124
self._network_name = None
127
return "%s(_network_name=%r)" % (self.__class__.__name__,
130
def get_format_description(self):
131
if self._network_name:
133
real_format = controldir.network_format_registry.get(
138
return 'Remote: ' + real_format.get_format_description()
139
return 'bzr remote bzrdir'
141
def get_format_string(self):
142
raise NotImplementedError(self.get_format_string)
144
def network_name(self):
145
if self._network_name:
146
return self._network_name
148
raise AssertionError("No network name set.")
150
def initialize_on_transport(self, transport):
152
# hand off the request to the smart server
153
client_medium = transport.get_smart_medium()
154
except errors.NoSmartMedium:
155
# TODO: lookup the local format from a server hint.
156
local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
157
return local_dir_format.initialize_on_transport(transport)
158
client = _SmartClient(client_medium)
159
path = client.remote_path_from_transport(transport)
161
response = client.call('BzrDirFormat.initialize', path)
162
except errors.ErrorFromSmartServer, err:
163
_translate_error(err, path=path)
164
if response[0] != 'ok':
165
raise errors.SmartProtocolError('unexpected response code %s' % (response,))
166
format = RemoteBzrDirFormat()
167
self._supply_sub_formats_to(format)
168
return RemoteBzrDir(transport, format)
170
def parse_NoneTrueFalse(self, arg):
177
raise AssertionError("invalid arg %r" % arg)
179
def _serialize_NoneTrueFalse(self, arg):
186
def _serialize_NoneString(self, arg):
189
def initialize_on_transport_ex(self, transport, use_existing_dir=False,
190
create_prefix=False, force_new_repo=False, stacked_on=None,
191
stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
194
# hand off the request to the smart server
195
client_medium = transport.get_smart_medium()
196
except errors.NoSmartMedium:
199
# Decline to open it if the server doesn't support our required
200
# version (3) so that the VFS-based transport will do it.
201
if client_medium.should_probe():
203
server_version = client_medium.protocol_version()
204
if server_version != '2':
208
except errors.SmartProtocolError:
209
# Apparently there's no usable smart server there, even though
210
# the medium supports the smart protocol.
215
client = _SmartClient(client_medium)
216
path = client.remote_path_from_transport(transport)
217
if client_medium._is_remote_before((1, 16)):
220
# TODO: lookup the local format from a server hint.
221
local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
222
self._supply_sub_formats_to(local_dir_format)
223
return local_dir_format.initialize_on_transport_ex(transport,
224
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
225
force_new_repo=force_new_repo, stacked_on=stacked_on,
226
stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
227
make_working_trees=make_working_trees, shared_repo=shared_repo,
229
return self._initialize_on_transport_ex_rpc(client, path, transport,
230
use_existing_dir, create_prefix, force_new_repo, stacked_on,
231
stack_on_pwd, repo_format_name, make_working_trees, shared_repo)
233
def _initialize_on_transport_ex_rpc(self, client, path, transport,
234
use_existing_dir, create_prefix, force_new_repo, stacked_on,
235
stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
237
args.append(self._serialize_NoneTrueFalse(use_existing_dir))
238
args.append(self._serialize_NoneTrueFalse(create_prefix))
239
args.append(self._serialize_NoneTrueFalse(force_new_repo))
240
args.append(self._serialize_NoneString(stacked_on))
241
# stack_on_pwd is often/usually our transport
244
stack_on_pwd = transport.relpath(stack_on_pwd)
247
except errors.PathNotChild:
249
args.append(self._serialize_NoneString(stack_on_pwd))
250
args.append(self._serialize_NoneString(repo_format_name))
251
args.append(self._serialize_NoneTrueFalse(make_working_trees))
252
args.append(self._serialize_NoneTrueFalse(shared_repo))
253
request_network_name = self._network_name or \
254
_mod_bzrdir.BzrDirFormat.get_default_format().network_name()
256
response = client.call('BzrDirFormat.initialize_ex_1.16',
257
request_network_name, path, *args)
258
except errors.UnknownSmartMethod:
259
client._medium._remember_remote_is_before((1,16))
260
local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
261
self._supply_sub_formats_to(local_dir_format)
262
return local_dir_format.initialize_on_transport_ex(transport,
263
use_existing_dir=use_existing_dir, create_prefix=create_prefix,
264
force_new_repo=force_new_repo, stacked_on=stacked_on,
265
stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
266
make_working_trees=make_working_trees, shared_repo=shared_repo,
268
except errors.ErrorFromSmartServer, err:
269
_translate_error(err, path=path)
270
repo_path = response[0]
271
bzrdir_name = response[6]
272
require_stacking = response[7]
273
require_stacking = self.parse_NoneTrueFalse(require_stacking)
274
format = RemoteBzrDirFormat()
275
format._network_name = bzrdir_name
276
self._supply_sub_formats_to(format)
277
bzrdir = RemoteBzrDir(transport, format, _client=client)
279
repo_format = response_tuple_to_repo_format(response[1:])
283
repo_bzrdir_format = RemoteBzrDirFormat()
284
repo_bzrdir_format._network_name = response[5]
285
repo_bzr = RemoteBzrDir(transport.clone(repo_path),
289
final_stack = response[8] or None
290
final_stack_pwd = response[9] or None
292
final_stack_pwd = urlutils.join(
293
transport.base, final_stack_pwd)
294
remote_repo = RemoteRepository(repo_bzr, repo_format)
295
if len(response) > 10:
296
# Updated server verb that locks remotely.
297
repo_lock_token = response[10] or None
298
remote_repo.lock_write(repo_lock_token, _skip_rpc=True)
300
remote_repo.dont_leave_lock_in_place()
302
remote_repo.lock_write()
303
policy = _mod_bzrdir.UseExistingRepository(remote_repo, final_stack,
304
final_stack_pwd, require_stacking)
305
policy.acquire_repository()
309
bzrdir._format.set_branch_format(self.get_branch_format())
311
# The repo has already been created, but we need to make sure that
312
# we'll make a stackable branch.
313
bzrdir._format.require_stacking(_skip_repo=True)
314
return remote_repo, bzrdir, require_stacking, policy
316
def _open(self, transport):
317
return RemoteBzrDir(transport, self)
319
def __eq__(self, other):
320
if not isinstance(other, RemoteBzrDirFormat):
322
return self.get_format_description() == other.get_format_description()
324
def __return_repository_format(self):
325
# Always return a RemoteRepositoryFormat object, but if a specific bzr
326
# repository format has been asked for, tell the RemoteRepositoryFormat
327
# that it should use that for init() etc.
328
result = RemoteRepositoryFormat()
329
custom_format = getattr(self, '_repository_format', None)
331
if isinstance(custom_format, RemoteRepositoryFormat):
334
# We will use the custom format to create repositories over the
335
# wire; expose its details like rich_root_data for code to
337
result._custom_format = custom_format
340
def get_branch_format(self):
341
result = _mod_bzrdir.BzrDirMetaFormat1.get_branch_format(self)
342
if not isinstance(result, RemoteBranchFormat):
343
new_result = RemoteBranchFormat()
344
new_result._custom_format = result
346
self.set_branch_format(new_result)
350
repository_format = property(__return_repository_format,
351
_mod_bzrdir.BzrDirMetaFormat1._set_repository_format) #.im_func)
354
class RemoteControlStore(_mod_config.IniFileStore):
355
"""Control store which attempts to use HPSS calls to retrieve control store.
357
Note that this is specific to bzr-based formats.
360
def __init__(self, bzrdir):
361
super(RemoteControlStore, self).__init__()
363
self._real_store = None
365
def lock_write(self, token=None):
367
return self._real_store.lock_write(token)
371
return self._real_store.unlock()
375
# We need to be able to override the undecorated implementation
376
self.save_without_locking()
378
def save_without_locking(self):
379
super(RemoteControlStore, self).save()
381
def _ensure_real(self):
382
self.bzrdir._ensure_real()
383
if self._real_store is None:
384
self._real_store = _mod_config.ControlStore(self.bzrdir)
386
def external_url(self):
387
return self.bzrdir.user_url
389
def _load_content(self):
390
medium = self.bzrdir._client._medium
391
path = self.bzrdir._path_for_remote_call(self.bzrdir._client)
393
response, handler = self.bzrdir._call_expecting_body(
394
'BzrDir.get_config_file', path)
395
except errors.UnknownSmartMethod:
397
return self._real_store._load_content()
398
if len(response) and response[0] != 'ok':
399
raise errors.UnexpectedSmartServerResponse(response)
400
return handler.read_body_bytes()
402
def _save_content(self, content):
403
# FIXME JRV 2011-11-22: Ideally this should use a
404
# HPSS call too, but at the moment it is not possible
405
# to write lock control directories.
407
return self._real_store._save_content(content)
410
class RemoteBzrDir(_mod_bzrdir.BzrDir, _RpcHelper):
87
# Note: RemoteBzrDirFormat is in bzrdir.py
89
class RemoteBzrDir(BzrDir, _RpcHelper):
411
90
"""Control directory on a remote server, accessed via bzr:// or similar."""
413
92
def __init__(self, transport, format, _client=None, _force_probe=False):
653
252
self._next_open_branch_result = result
656
def destroy_branch(self, name=None):
255
def destroy_branch(self):
657
256
"""See BzrDir.destroy_branch"""
659
name = self._get_selected_branch()
661
raise errors.NoColocatedBranchSupport(self)
662
path = self._path_for_remote_call(self._client)
668
response = self._call('BzrDir.destroy_branch', path, *args)
669
except errors.UnknownSmartMethod:
671
self._real_bzrdir.destroy_branch(name=name)
672
self._next_open_branch_result = None
258
self._real_bzrdir.destroy_branch()
674
259
self._next_open_branch_result = None
675
if response[0] != 'ok':
676
raise SmartProtocolError('unexpected response code %s' % (response,))
678
def create_workingtree(self, revision_id=None, from_branch=None,
679
accelerator_tree=None, hardlink=False):
261
def create_workingtree(self, revision_id=None, from_branch=None):
680
262
raise errors.NotLocalUrl(self.transport.base)
682
def find_branch_format(self, name=None):
264
def find_branch_format(self):
683
265
"""Find the branch 'format' for this bzrdir.
685
267
This might be a synthetic object for e.g. RemoteBranch and SVN.
687
b = self.open_branch(name=name)
269
b = self.open_branch()
690
def get_branches(self, possible_transports=None, ignore_fallbacks=False):
691
path = self._path_for_remote_call(self._client)
693
response, handler = self._call_expecting_body(
694
'BzrDir.get_branches', path)
695
except errors.UnknownSmartMethod:
697
return self._real_bzrdir.get_branches()
698
if response[0] != "success":
699
raise errors.UnexpectedSmartServerResponse(response)
700
body = bencode.bdecode(handler.read_body_bytes())
702
for (name, value) in body.iteritems():
703
ret[name] = self._open_branch(name, value[0], value[1],
704
possible_transports=possible_transports,
705
ignore_fallbacks=ignore_fallbacks)
708
def set_branch_reference(self, target_branch, name=None):
709
"""See BzrDir.set_branch_reference()."""
711
name = self._get_selected_branch()
713
raise errors.NoColocatedBranchSupport(self)
715
return self._real_bzrdir.set_branch_reference(target_branch, name=name)
717
def get_branch_reference(self, name=None):
272
def get_branch_reference(self):
718
273
"""See BzrDir.get_branch_reference()."""
720
name = self._get_selected_branch()
722
raise errors.NoColocatedBranchSupport(self)
723
274
response = self._get_branch_reference()
724
275
if response[0] == 'ref':
725
276
return response[1]
729
280
def _get_branch_reference(self):
730
281
path = self._path_for_remote_call(self._client)
731
282
medium = self._client._medium
733
('BzrDir.open_branchV3', (2, 1)),
734
('BzrDir.open_branchV2', (1, 13)),
735
('BzrDir.open_branch', None),
737
for verb, required_version in candidate_calls:
738
if required_version and medium._is_remote_before(required_version):
283
if not medium._is_remote_before((1, 13)):
741
response = self._call(verb, path)
285
response = self._call('BzrDir.open_branchV2', path)
286
if response[0] not in ('ref', 'branch'):
287
raise errors.UnexpectedSmartServerResponse(response)
742
289
except errors.UnknownSmartMethod:
743
if required_version is None:
745
medium._remember_remote_is_before(required_version)
748
if verb == 'BzrDir.open_branch':
749
if response[0] != 'ok':
750
raise errors.UnexpectedSmartServerResponse(response)
751
if response[1] != '':
752
return ('ref', response[1])
754
return ('branch', '')
755
if response[0] not in ('ref', 'branch'):
290
medium._remember_remote_is_before((1, 13))
291
response = self._call('BzrDir.open_branch', path)
292
if response[0] != 'ok':
756
293
raise errors.UnexpectedSmartServerResponse(response)
294
if response[1] != '':
295
return ('ref', response[1])
297
return ('branch', '')
759
def _get_tree_branch(self, name=None):
299
def _get_tree_branch(self):
760
300
"""See BzrDir._get_tree_branch()."""
761
return None, self.open_branch(name=name)
301
return None, self.open_branch()
763
def _open_branch(self, name, kind, location_or_format,
764
ignore_fallbacks=False, possible_transports=None):
303
def open_branch(self, _unsupported=False, ignore_fallbacks=False):
305
raise NotImplementedError('unsupported flag support not implemented yet.')
306
if self._next_open_branch_result is not None:
307
# See create_branch for details.
308
result = self._next_open_branch_result
309
self._next_open_branch_result = None
311
response = self._get_branch_reference()
312
if response[0] == 'ref':
766
313
# a branch reference, use the existing BranchReference logic.
767
314
format = BranchReferenceFormat()
768
return format.open(self, name=name, _found=True,
769
location=location_or_format, ignore_fallbacks=ignore_fallbacks,
770
possible_transports=possible_transports)
771
branch_format_name = location_or_format
315
return format.open(self, _found=True, location=response[1],
316
ignore_fallbacks=ignore_fallbacks)
317
branch_format_name = response[1]
772
318
if not branch_format_name:
773
319
branch_format_name = None
774
320
format = RemoteBranchFormat(network_name=branch_format_name)
775
321
return RemoteBranch(self, self.find_repository(), format=format,
776
setup_stacking=not ignore_fallbacks, name=name,
777
possible_transports=possible_transports)
779
def open_branch(self, name=None, unsupported=False,
780
ignore_fallbacks=False, possible_transports=None):
782
name = self._get_selected_branch()
784
raise errors.NoColocatedBranchSupport(self)
786
raise NotImplementedError('unsupported flag support not implemented yet.')
787
if self._next_open_branch_result is not None:
788
# See create_branch for details.
789
result = self._next_open_branch_result
790
self._next_open_branch_result = None
792
response = self._get_branch_reference()
793
return self._open_branch(name, response[0], response[1],
794
possible_transports=possible_transports,
795
ignore_fallbacks=ignore_fallbacks)
322
setup_stacking=not ignore_fallbacks)
797
324
def _open_repo_v1(self, path):
798
325
verb = 'BzrDir.find_repository'
1768
1145
raise errors.UnexpectedSmartServerResponse(response)
1771
1147
def sprout(self, to_bzrdir, revision_id=None):
1772
"""Create a descendent repository for new development.
1774
Unlike clone, this does not copy the settings of the repository.
1776
dest_repo = self._create_sprouting_repo(to_bzrdir, shared=False)
1148
# TODO: Option to control what format is created?
1150
dest_repo = self._real_repository._format.initialize(to_bzrdir,
1777
1152
dest_repo.fetch(self, revision_id=revision_id)
1778
1153
return dest_repo
1780
def _create_sprouting_repo(self, a_bzrdir, shared):
1781
if not isinstance(a_bzrdir._format, self.bzrdir._format.__class__):
1782
# use target default format.
1783
dest_repo = a_bzrdir.create_repository()
1785
# Most control formats need the repository to be specifically
1786
# created, but on some old all-in-one formats it's not needed
1788
dest_repo = self._format.initialize(a_bzrdir, shared=shared)
1789
except errors.UninitializableFormat:
1790
dest_repo = a_bzrdir.open_repository()
1793
1155
### These methods are just thin shims to the VFS object for now.
1796
1157
def revision_tree(self, revision_id):
1797
revision_id = _mod_revision.ensure_null(revision_id)
1798
if revision_id == _mod_revision.NULL_REVISION:
1799
return InventoryRevisionTree(self,
1800
Inventory(root_id=None), _mod_revision.NULL_REVISION)
1802
return list(self.revision_trees([revision_id]))[0]
1159
return self._real_repository.revision_tree(revision_id)
1804
1161
def get_serializer_format(self):
1805
path = self.bzrdir._path_for_remote_call(self._client)
1807
response = self._call('VersionedFileRepository.get_serializer_format',
1809
except errors.UnknownSmartMethod:
1811
return self._real_repository.get_serializer_format()
1812
if response[0] != 'ok':
1813
raise errors.UnexpectedSmartServerResponse(response)
1163
return self._real_repository.get_serializer_format()
1816
1165
def get_commit_builder(self, branch, parents, config, timestamp=None,
1817
1166
timezone=None, committer=None, revprops=None,
1818
revision_id=None, lossy=False):
1819
"""Obtain a CommitBuilder for this repository.
1821
:param branch: Branch to commit to.
1822
:param parents: Revision ids of the parents of the new revision.
1823
:param config: Configuration to use.
1824
:param timestamp: Optional timestamp recorded for commit.
1825
:param timezone: Optional timezone for timestamp.
1826
:param committer: Optional committer to set for commit.
1827
:param revprops: Optional dictionary of revision properties.
1828
:param revision_id: Optional revision id.
1829
:param lossy: Whether to discard data that can not be natively
1830
represented, when pushing to a foreign VCS
1832
if self._fallback_repositories and not self._format.supports_chks:
1833
raise errors.BzrError("Cannot commit directly to a stacked branch"
1834
" in pre-2a formats. See "
1835
"https://bugs.launchpad.net/bzr/+bug/375013 for details.")
1836
if self._format.rich_root_data:
1837
commit_builder_kls = vf_repository.VersionedFileRootCommitBuilder
1839
commit_builder_kls = vf_repository.VersionedFileCommitBuilder
1840
result = commit_builder_kls(self, parents, config,
1841
timestamp, timezone, committer, revprops, revision_id,
1843
self.start_write_group()
1168
# FIXME: It ought to be possible to call this without immediately
1169
# triggering _ensure_real. For now it's the easiest thing to do.
1171
real_repo = self._real_repository
1172
builder = real_repo.get_commit_builder(branch, parents,
1173
config, timestamp=timestamp, timezone=timezone,
1174
committer=committer, revprops=revprops, revision_id=revision_id)
1846
1177
def add_fallback_repository(self, repository):
1847
1178
"""Add a repository to use for looking up data not held locally.
1866
1195
# _real_branch had its get_stacked_on_url method called), then the
1867
1196
# repository to be added may already be in the _real_repositories list.
1868
1197
if self._real_repository is not None:
1869
fallback_locations = [repo.user_url for repo in
1198
fallback_locations = [repo.bzrdir.root_transport.base for repo in
1870
1199
self._real_repository._fallback_repositories]
1871
if repository.user_url not in fallback_locations:
1200
if repository.bzrdir.root_transport.base not in fallback_locations:
1872
1201
self._real_repository.add_fallback_repository(repository)
1874
def _check_fallback_repository(self, repository):
1875
"""Check that this repository can fallback to repository safely.
1877
Raise an error if not.
1879
:param repository: A repository to fallback to.
1881
return _mod_repository.InterRepository._assert_same_model(
1884
1203
def add_inventory(self, revid, inv, parents):
1885
1204
self._ensure_real()
1886
1205
return self._real_repository.add_inventory(revid, inv, parents)
1888
1207
def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1889
parents, basis_inv=None, propagate_caches=False):
1890
1209
self._ensure_real()
1891
1210
return self._real_repository.add_inventory_by_delta(basis_revision_id,
1892
delta, new_revision_id, parents, basis_inv=basis_inv,
1893
propagate_caches=propagate_caches)
1895
def add_revision(self, revision_id, rev, inv=None):
1896
_mod_revision.check_not_reserved_id(revision_id)
1897
key = (revision_id,)
1898
# check inventory present
1899
if not self.inventories.get_parent_map([key]):
1901
raise errors.WeaveRevisionNotPresent(revision_id,
1904
# yes, this is not suitable for adding with ghosts.
1905
rev.inventory_sha1 = self.add_inventory(revision_id, inv,
1908
rev.inventory_sha1 = self.inventories.get_sha1s([key])[key]
1909
self._add_revision(rev)
1911
def _add_revision(self, rev):
1912
if self._real_repository is not None:
1913
return self._real_repository._add_revision(rev)
1914
text = self._serializer.write_revision_to_string(rev)
1915
key = (rev.revision_id,)
1916
parents = tuple((parent,) for parent in rev.parent_ids)
1917
self._write_group_tokens, missing_keys = self._get_sink().insert_stream(
1918
[('revisions', [FulltextContentFactory(key, parents, None, text)])],
1919
self._format, self._write_group_tokens)
1211
delta, new_revision_id, parents)
1213
def add_revision(self, rev_id, rev, inv=None, config=None):
1215
return self._real_repository.add_revision(
1216
rev_id, rev, inv=inv, config=config)
1921
1218
@needs_read_lock
1922
1219
def get_inventory(self, revision_id):
1923
return list(self.iter_inventories([revision_id]))[0]
1925
def _iter_inventories_rpc(self, revision_ids, ordering):
1926
if ordering is None:
1927
ordering = 'unordered'
1928
path = self.bzrdir._path_for_remote_call(self._client)
1929
body = "\n".join(revision_ids)
1930
response_tuple, response_handler = (
1931
self._call_with_body_bytes_expecting_body(
1932
"VersionedFileRepository.get_inventories",
1933
(path, ordering), body))
1934
if response_tuple[0] != "ok":
1935
raise errors.UnexpectedSmartServerResponse(response_tuple)
1936
deserializer = inventory_delta.InventoryDeltaDeserializer()
1937
byte_stream = response_handler.read_streamed_body()
1938
decoded = smart_repo._byte_stream_to_stream(byte_stream)
1940
# no results whatsoever
1942
src_format, stream = decoded
1943
if src_format.network_name() != self._format.network_name():
1944
raise AssertionError(
1945
"Mismatched RemoteRepository and stream src %r, %r" % (
1946
src_format.network_name(), self._format.network_name()))
1947
# ignore the src format, it's not really relevant
1948
prev_inv = Inventory(root_id=None,
1949
revision_id=_mod_revision.NULL_REVISION)
1950
# there should be just one substream, with inventory deltas
1951
substream_kind, substream = stream.next()
1952
if substream_kind != "inventory-deltas":
1953
raise AssertionError(
1954
"Unexpected stream %r received" % substream_kind)
1955
for record in substream:
1956
(parent_id, new_id, versioned_root, tree_references, invdelta) = (
1957
deserializer.parse_text_bytes(record.get_bytes_as("fulltext")))
1958
if parent_id != prev_inv.revision_id:
1959
raise AssertionError("invalid base %r != %r" % (parent_id,
1960
prev_inv.revision_id))
1961
inv = prev_inv.create_by_apply_delta(invdelta, new_id)
1962
yield inv, inv.revision_id
1965
def _iter_inventories_vfs(self, revision_ids, ordering=None):
1966
1220
self._ensure_real()
1967
return self._real_repository._iter_inventories(revision_ids, ordering)
1221
return self._real_repository.get_inventory(revision_id)
1969
1223
def iter_inventories(self, revision_ids, ordering=None):
1970
"""Get many inventories by revision_ids.
1972
This will buffer some or all of the texts used in constructing the
1973
inventories in memory, but will only parse a single inventory at a
1976
:param revision_ids: The expected revision ids of the inventories.
1977
:param ordering: optional ordering, e.g. 'topological'. If not
1978
specified, the order of revision_ids will be preserved (by
1979
buffering if necessary).
1980
:return: An iterator of inventories.
1982
if ((None in revision_ids)
1983
or (_mod_revision.NULL_REVISION in revision_ids)):
1984
raise ValueError('cannot get null revision inventory')
1985
for inv, revid in self._iter_inventories(revision_ids, ordering):
1987
raise errors.NoSuchRevision(self, revid)
1990
def _iter_inventories(self, revision_ids, ordering=None):
1991
if len(revision_ids) == 0:
1993
missing = set(revision_ids)
1994
if ordering is None:
1995
order_as_requested = True
1997
order = list(revision_ids)
1999
next_revid = order.pop()
2001
order_as_requested = False
2002
if ordering != 'unordered' and self._fallback_repositories:
2003
raise ValueError('unsupported ordering %r' % ordering)
2004
iter_inv_fns = [self._iter_inventories_rpc] + [
2005
fallback._iter_inventories for fallback in
2006
self._fallback_repositories]
2008
for iter_inv in iter_inv_fns:
2009
request = [revid for revid in revision_ids if revid in missing]
2010
for inv, revid in iter_inv(request, ordering):
2013
missing.remove(inv.revision_id)
2014
if ordering != 'unordered':
2018
if order_as_requested:
2019
# Yield as many results as we can while preserving order.
2020
while next_revid in invs:
2021
inv = invs.pop(next_revid)
2022
yield inv, inv.revision_id
2024
next_revid = order.pop()
2026
# We still want to fully consume the stream, just
2027
# in case it is not actually finished at this point
2030
except errors.UnknownSmartMethod:
2031
for inv, revid in self._iter_inventories_vfs(revision_ids, ordering):
2035
if order_as_requested:
2036
if next_revid is not None:
2037
yield None, next_revid
2040
yield invs.get(revid), revid
2043
yield None, missing.pop()
1225
return self._real_repository.iter_inventories(revision_ids, ordering)
2045
1227
@needs_read_lock
2046
1228
def get_revision(self, revision_id):
2047
return self.get_revisions([revision_id])[0]
1230
return self._real_repository.get_revision(revision_id)
2049
1232
def get_transaction(self):
2050
1233
self._ensure_real()
2095
1266
included_keys = result_set.intersection(result_parents)
2096
1267
start_keys = result_set.difference(included_keys)
2097
1268
exclude_keys = result_parents.difference(result_set)
2098
result = vf_search.SearchResult(start_keys, exclude_keys,
1269
result = graph.SearchResult(start_keys, exclude_keys,
2099
1270
len(result_set), result_set)
2102
1273
@needs_read_lock
2103
def search_missing_revision_ids(self, other,
2104
revision_id=symbol_versioning.DEPRECATED_PARAMETER,
2105
find_ghosts=True, revision_ids=None, if_present_ids=None,
1274
def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
2107
1275
"""Return the revision ids that other has that this does not.
2109
1277
These are returned in topological order.
2111
1279
revision_id: only return revision ids included by revision_id.
2113
if symbol_versioning.deprecated_passed(revision_id):
2114
symbol_versioning.warn(
2115
'search_missing_revision_ids(revision_id=...) was '
2116
'deprecated in 2.4. Use revision_ids=[...] instead.',
2117
DeprecationWarning, stacklevel=2)
2118
if revision_ids is not None:
2119
raise AssertionError(
2120
'revision_ids is mutually exclusive with revision_id')
2121
if revision_id is not None:
2122
revision_ids = [revision_id]
2123
inter_repo = _mod_repository.InterRepository.get(other, self)
2124
return inter_repo.search_missing_revision_ids(
2125
find_ghosts=find_ghosts, revision_ids=revision_ids,
2126
if_present_ids=if_present_ids, limit=limit)
1281
return repository.InterRepository.get(
1282
other, self).search_missing_revision_ids(revision_id, find_ghosts)
2128
def fetch(self, source, revision_id=None, find_ghosts=False,
1284
def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
2129
1285
fetch_spec=None):
2130
1286
# No base implementation to use as RemoteRepository is not a subclass
2131
1287
# of Repository; so this is a copy of Repository.fetch().
2176
1326
return self._real_repository._get_versioned_file_checker(
2177
1327
revisions, revision_versions_cache)
2179
def _iter_files_bytes_rpc(self, desired_files, absent):
2180
path = self.bzrdir._path_for_remote_call(self._client)
2183
for (file_id, revid, identifier) in desired_files:
2184
lines.append("%s\0%s" % (
2185
osutils.safe_file_id(file_id),
2186
osutils.safe_revision_id(revid)))
2187
identifiers.append(identifier)
2188
(response_tuple, response_handler) = (
2189
self._call_with_body_bytes_expecting_body(
2190
"Repository.iter_files_bytes", (path, ), "\n".join(lines)))
2191
if response_tuple != ('ok', ):
2192
response_handler.cancel_read_body()
2193
raise errors.UnexpectedSmartServerResponse(response_tuple)
2194
byte_stream = response_handler.read_streamed_body()
2195
def decompress_stream(start, byte_stream, unused):
2196
decompressor = zlib.decompressobj()
2197
yield decompressor.decompress(start)
2198
while decompressor.unused_data == "":
2200
data = byte_stream.next()
2201
except StopIteration:
2203
yield decompressor.decompress(data)
2204
yield decompressor.flush()
2205
unused.append(decompressor.unused_data)
2208
while not "\n" in unused:
2209
unused += byte_stream.next()
2210
header, rest = unused.split("\n", 1)
2211
args = header.split("\0")
2212
if args[0] == "absent":
2213
absent[identifiers[int(args[3])]] = (args[1], args[2])
2216
elif args[0] == "ok":
2219
raise errors.UnexpectedSmartServerResponse(args)
2221
yield (identifiers[idx],
2222
decompress_stream(rest, byte_stream, unused_chunks))
2223
unused = "".join(unused_chunks)
2225
1329
def iter_files_bytes(self, desired_files):
2226
1330
"""See Repository.iter_file_bytes.
2230
for (identifier, bytes_iterator) in self._iter_files_bytes_rpc(
2231
desired_files, absent):
2232
yield identifier, bytes_iterator
2233
for fallback in self._fallback_repositories:
2236
desired_files = [(key[0], key[1], identifier) for
2237
(identifier, key) in absent.iteritems()]
2238
for (identifier, bytes_iterator) in fallback.iter_files_bytes(desired_files):
2239
del absent[identifier]
2240
yield identifier, bytes_iterator
2242
# There may be more missing items, but raise an exception
2244
missing_identifier = absent.keys()[0]
2245
missing_key = absent[missing_identifier]
2246
raise errors.RevisionNotPresent(revision_id=missing_key[1],
2247
file_id=missing_key[0])
2248
except errors.UnknownSmartMethod:
2250
for (identifier, bytes_iterator) in (
2251
self._real_repository.iter_files_bytes(desired_files)):
2252
yield identifier, bytes_iterator
2254
def get_cached_parent_map(self, revision_ids):
2255
"""See bzrlib.CachingParentsProvider.get_cached_parent_map"""
2256
return self._unstacked_provider.get_cached_parent_map(revision_ids)
1333
return self._real_repository.iter_files_bytes(desired_files)
2258
1335
def get_parent_map(self, revision_ids):
2259
1336
"""See bzrlib.Graph.get_parent_map()."""
2382
1470
@needs_read_lock
2383
1471
def get_signature_text(self, revision_id):
2384
path = self.bzrdir._path_for_remote_call(self._client)
2386
response_tuple, response_handler = self._call_expecting_body(
2387
'Repository.get_revision_signature_text', path, revision_id)
2388
except errors.UnknownSmartMethod:
2390
return self._real_repository.get_signature_text(revision_id)
2391
except errors.NoSuchRevision, err:
2392
for fallback in self._fallback_repositories:
2394
return fallback.get_signature_text(revision_id)
2395
except errors.NoSuchRevision:
2399
if response_tuple[0] != 'ok':
2400
raise errors.UnexpectedSmartServerResponse(response_tuple)
2401
return response_handler.read_body_bytes()
1473
return self._real_repository.get_signature_text(revision_id)
2403
1475
@needs_read_lock
2404
def _get_inventory_xml(self, revision_id):
2405
# This call is used by older working tree formats,
2406
# which stored a serialized basis inventory.
2408
return self._real_repository._get_inventory_xml(revision_id)
1476
def get_inventory_xml(self, revision_id):
1478
return self._real_repository.get_inventory_xml(revision_id)
1480
def deserialise_inventory(self, revision_id, xml):
1482
return self._real_repository.deserialise_inventory(revision_id, xml)
2411
1484
def reconcile(self, other=None, thorough=False):
2412
from bzrlib.reconcile import RepoReconciler
2413
path = self.bzrdir._path_for_remote_call(self._client)
2415
response, handler = self._call_expecting_body(
2416
'Repository.reconcile', path, self._lock_token)
2417
except (errors.UnknownSmartMethod, errors.TokenLockingNotSupported):
2419
return self._real_repository.reconcile(other=other, thorough=thorough)
2420
if response != ('ok', ):
2421
raise errors.UnexpectedSmartServerResponse(response)
2422
body = handler.read_body_bytes()
2423
result = RepoReconciler(self)
2424
for line in body.split('\n'):
2427
key, val_text = line.split(':')
2428
if key == "garbage_inventories":
2429
result.garbage_inventories = int(val_text)
2430
elif key == "inconsistent_parents":
2431
result.inconsistent_parents = int(val_text)
2433
mutter("unknown reconcile key %r" % key)
1486
return self._real_repository.reconcile(other=other, thorough=thorough)
2436
1488
def all_revision_ids(self):
2437
path = self.bzrdir._path_for_remote_call(self._client)
2439
response_tuple, response_handler = self._call_expecting_body(
2440
"Repository.all_revision_ids", path)
2441
except errors.UnknownSmartMethod:
2443
return self._real_repository.all_revision_ids()
2444
if response_tuple != ("ok", ):
2445
raise errors.UnexpectedSmartServerResponse(response_tuple)
2446
revids = set(response_handler.read_body_bytes().splitlines())
2447
for fallback in self._fallback_repositories:
2448
revids.update(set(fallback.all_revision_ids()))
2451
def _filtered_revision_trees(self, revision_ids, file_ids):
2452
"""Return Tree for a revision on this branch with only some files.
2454
:param revision_ids: a sequence of revision-ids;
2455
a revision-id may not be None or 'null:'
2456
:param file_ids: if not None, the result is filtered
2457
so that only those file-ids, their parents and their
2458
children are included.
2460
inventories = self.iter_inventories(revision_ids)
2461
for inv in inventories:
2462
# Should we introduce a FilteredRevisionTree class rather
2463
# than pre-filter the inventory here?
2464
filtered_inv = inv.filter(file_ids)
2465
yield InventoryRevisionTree(self, filtered_inv, filtered_inv.revision_id)
1490
return self._real_repository.all_revision_ids()
2467
1492
@needs_read_lock
2468
1493
def get_deltas_for_revisions(self, revisions, specific_fileids=None):
2469
medium = self._client._medium
2470
if medium._is_remote_before((1, 2)):
2472
for delta in self._real_repository.get_deltas_for_revisions(
2473
revisions, specific_fileids):
2476
# Get the revision-ids of interest
2477
required_trees = set()
2478
for revision in revisions:
2479
required_trees.add(revision.revision_id)
2480
required_trees.update(revision.parent_ids[:1])
2482
# Get the matching filtered trees. Note that it's more
2483
# efficient to pass filtered trees to changes_from() rather
2484
# than doing the filtering afterwards. changes_from() could
2485
# arguably do the filtering itself but it's path-based, not
2486
# file-id based, so filtering before or afterwards is
2488
if specific_fileids is None:
2489
trees = dict((t.get_revision_id(), t) for
2490
t in self.revision_trees(required_trees))
2492
trees = dict((t.get_revision_id(), t) for
2493
t in self._filtered_revision_trees(required_trees,
2496
# Calculate the deltas
2497
for revision in revisions:
2498
if not revision.parent_ids:
2499
old_tree = self.revision_tree(_mod_revision.NULL_REVISION)
2501
old_tree = trees[revision.parent_ids[0]]
2502
yield trees[revision.revision_id].changes_from(old_tree)
1495
return self._real_repository.get_deltas_for_revisions(revisions,
1496
specific_fileids=specific_fileids)
2504
1498
@needs_read_lock
2505
1499
def get_revision_delta(self, revision_id, specific_fileids=None):
2506
r = self.get_revision(revision_id)
2507
return list(self.get_deltas_for_revisions([r],
2508
specific_fileids=specific_fileids))[0]
1501
return self._real_repository.get_revision_delta(revision_id,
1502
specific_fileids=specific_fileids)
2510
1504
@needs_read_lock
2511
1505
def revision_trees(self, revision_ids):
2512
inventories = self.iter_inventories(revision_ids)
2513
for inv in inventories:
2514
yield InventoryRevisionTree(self, inv, inv.revision_id)
1507
return self._real_repository.revision_trees(revision_ids)
2516
1509
@needs_read_lock
2517
1510
def get_revision_reconcile(self, revision_id):
2642
1622
self._ensure_real()
2643
1623
return self._real_repository.texts
2645
def _iter_revisions_rpc(self, revision_ids):
2646
body = "\n".join(revision_ids)
2647
path = self.bzrdir._path_for_remote_call(self._client)
2648
response_tuple, response_handler = (
2649
self._call_with_body_bytes_expecting_body(
2650
"Repository.iter_revisions", (path, ), body))
2651
if response_tuple[0] != "ok":
2652
raise errors.UnexpectedSmartServerResponse(response_tuple)
2653
serializer_format = response_tuple[1]
2654
serializer = serializer_format_registry.get(serializer_format)
2655
byte_stream = response_handler.read_streamed_body()
2656
decompressor = zlib.decompressobj()
2658
for bytes in byte_stream:
2659
chunks.append(decompressor.decompress(bytes))
2660
if decompressor.unused_data != "":
2661
chunks.append(decompressor.flush())
2662
yield serializer.read_revision_from_string("".join(chunks))
2663
unused = decompressor.unused_data
2664
decompressor = zlib.decompressobj()
2665
chunks = [decompressor.decompress(unused)]
2666
chunks.append(decompressor.flush())
2667
text = "".join(chunks)
2669
yield serializer.read_revision_from_string("".join(chunks))
2671
1625
@needs_read_lock
2672
1626
def get_revisions(self, revision_ids):
2673
if revision_ids is None:
2674
revision_ids = self.all_revision_ids()
2676
for rev_id in revision_ids:
2677
if not rev_id or not isinstance(rev_id, basestring):
2678
raise errors.InvalidRevisionId(
2679
revision_id=rev_id, branch=self)
2681
missing = set(revision_ids)
2683
for rev in self._iter_revisions_rpc(revision_ids):
2684
missing.remove(rev.revision_id)
2685
revs[rev.revision_id] = rev
2686
except errors.UnknownSmartMethod:
2688
return self._real_repository.get_revisions(revision_ids)
2689
for fallback in self._fallback_repositories:
2692
for revid in list(missing):
2693
# XXX JRV 2011-11-20: It would be nice if there was a
2694
# public method on Repository that could be used to query
2695
# for revision objects *without* failing completely if one
2696
# was missing. There is VersionedFileRepository._iter_revisions,
2697
# but unfortunately that's private and not provided by
2698
# all repository implementations.
2700
revs[revid] = fallback.get_revision(revid)
2701
except errors.NoSuchRevision:
2704
missing.remove(revid)
2706
raise errors.NoSuchRevision(self, list(missing)[0])
2707
return [revs[revid] for revid in revision_ids]
1628
return self._real_repository.get_revisions(revision_ids)
2709
1630
def supports_rich_root(self):
2710
1631
return self._format.rich_root_data
2712
@symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2713
1633
def iter_reverse_revision_history(self, revision_id):
2714
1634
self._ensure_real()
2715
1635
return self._real_repository.iter_reverse_revision_history(revision_id)
2718
1638
def _serializer(self):
2719
1639
return self._format._serializer
2722
1641
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
2723
signature = gpg_strategy.sign(plaintext)
2724
self.add_signature_text(revision_id, signature)
1643
return self._real_repository.store_revision_signature(
1644
gpg_strategy, plaintext, revision_id)
2726
1646
def add_signature_text(self, revision_id, signature):
2727
if self._real_repository:
2728
# If there is a real repository the write group will
2729
# be in the real repository as well, so use that:
2731
return self._real_repository.add_signature_text(
2732
revision_id, signature)
2733
path = self.bzrdir._path_for_remote_call(self._client)
2734
response, handler = self._call_with_body_bytes_expecting_body(
2735
'Repository.add_signature_text', (path, self._lock_token,
2736
revision_id) + tuple(self._write_group_tokens), signature)
2737
handler.cancel_read_body()
2739
if response[0] != 'ok':
2740
raise errors.UnexpectedSmartServerResponse(response)
2741
self._write_group_tokens = response[1:]
1648
return self._real_repository.add_signature_text(revision_id, signature)
2743
1650
def has_signature_for_revision_id(self, revision_id):
2744
path = self.bzrdir._path_for_remote_call(self._client)
2746
response = self._call('Repository.has_signature_for_revision_id',
2748
except errors.UnknownSmartMethod:
2750
return self._real_repository.has_signature_for_revision_id(
2752
if response[0] not in ('yes', 'no'):
2753
raise SmartProtocolError('unexpected response code %s' % (response,))
2754
if response[0] == 'yes':
2756
for fallback in self._fallback_repositories:
2757
if fallback.has_signature_for_revision_id(revision_id):
2762
def verify_revision_signature(self, revision_id, gpg_strategy):
2763
if not self.has_signature_for_revision_id(revision_id):
2764
return gpg.SIGNATURE_NOT_SIGNED, None
2765
signature = self.get_signature_text(revision_id)
2767
testament = _mod_testament.Testament.from_revision(self, revision_id)
2768
plaintext = testament.as_short_text()
2770
return gpg_strategy.verify(signature, plaintext)
1652
return self._real_repository.has_signature_for_revision_id(revision_id)
2772
1654
def item_keys_introduced_by(self, revision_ids, _files_pb=None):
2773
1655
self._ensure_real()
2774
1656
return self._real_repository.item_keys_introduced_by(revision_ids,
2775
1657
_files_pb=_files_pb)
1659
def revision_graph_can_have_wrong_parents(self):
1660
# The answer depends on the remote repo format.
1662
return self._real_repository.revision_graph_can_have_wrong_parents()
2777
1664
def _find_inconsistent_revision_parents(self, revisions_iterator=None):
2778
1665
self._ensure_real()
2779
1666
return self._real_repository._find_inconsistent_revision_parents(
3112
1992
def _ensure_real(self):
3113
1993
if self._custom_format is None:
3115
self._custom_format = branch.network_format_registry.get(
3118
raise errors.UnknownFormatError(kind='branch',
3119
format=self._network_name)
1994
self._custom_format = branch.network_format_registry.get(
3121
1997
def get_format_description(self):
3123
return 'Remote: ' + self._custom_format.get_format_description()
1998
return 'Remote BZR Branch'
3125
2000
def network_name(self):
3126
2001
return self._network_name
3128
def open(self, a_bzrdir, name=None, ignore_fallbacks=False):
3129
return a_bzrdir.open_branch(name=name,
3130
ignore_fallbacks=ignore_fallbacks)
2003
def open(self, a_bzrdir, ignore_fallbacks=False):
2004
return a_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
3132
def _vfs_initialize(self, a_bzrdir, name, append_revisions_only):
2006
def _vfs_initialize(self, a_bzrdir):
3133
2007
# Initialisation when using a local bzrdir object, or a non-vfs init
3134
2008
# method is not available on the server.
3135
2009
# self._custom_format is always set - the start of initialize ensures
3137
2011
if isinstance(a_bzrdir, RemoteBzrDir):
3138
2012
a_bzrdir._ensure_real()
3139
result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
3140
name=name, append_revisions_only=append_revisions_only)
2013
result = self._custom_format.initialize(a_bzrdir._real_bzrdir)
3142
2015
# We assume the bzrdir is parameterised; it may not be.
3143
result = self._custom_format.initialize(a_bzrdir, name=name,
3144
append_revisions_only=append_revisions_only)
2016
result = self._custom_format.initialize(a_bzrdir)
3145
2017
if (isinstance(a_bzrdir, RemoteBzrDir) and
3146
2018
not isinstance(result, RemoteBranch)):
3147
result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2019
result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result)
3151
def initialize(self, a_bzrdir, name=None, repository=None,
3152
append_revisions_only=None):
3154
name = a_bzrdir._get_selected_branch()
2022
def initialize(self, a_bzrdir):
3155
2023
# 1) get the network name to use.
3156
2024
if self._custom_format:
3157
2025
network_name = self._custom_format.network_name()
3159
2027
# Select the current bzrlib default and ask for that.
3160
reference_bzrdir_format = controldir.format_registry.get('default')()
2028
reference_bzrdir_format = bzrdir.format_registry.get('default')()
3161
2029
reference_format = reference_bzrdir_format.get_branch_format()
3162
2030
self._custom_format = reference_format
3163
2031
network_name = reference_format.network_name()
3164
2032
# Being asked to create on a non RemoteBzrDir:
3165
2033
if not isinstance(a_bzrdir, RemoteBzrDir):
3166
return self._vfs_initialize(a_bzrdir, name=name,
3167
append_revisions_only=append_revisions_only)
2034
return self._vfs_initialize(a_bzrdir)
3168
2035
medium = a_bzrdir._client._medium
3169
2036
if medium._is_remote_before((1, 13)):
3170
return self._vfs_initialize(a_bzrdir, name=name,
3171
append_revisions_only=append_revisions_only)
2037
return self._vfs_initialize(a_bzrdir)
3172
2038
# Creating on a remote bzr dir.
3173
2039
# 2) try direct creation via RPC
3174
2040
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
3176
# XXX JRV20100304: Support creating colocated branches
3177
raise errors.NoColocatedBranchSupport(self)
3178
2041
verb = 'BzrDir.create_branch'
3180
2043
response = a_bzrdir._call(verb, path, network_name)
3181
2044
except errors.UnknownSmartMethod:
3182
2045
# Fallback - use vfs methods
3183
2046
medium._remember_remote_is_before((1, 13))
3184
return self._vfs_initialize(a_bzrdir, name=name,
3185
append_revisions_only=append_revisions_only)
2047
return self._vfs_initialize(a_bzrdir)
3186
2048
if response[0] != 'ok':
3187
2049
raise errors.UnexpectedSmartServerResponse(response)
3188
2050
# Turn the response into a RemoteRepository object.
3189
2051
format = RemoteBranchFormat(network_name=response[1])
3190
2052
repo_format = response_tuple_to_repo_format(response[3:])
3191
repo_path = response[2]
3192
if repository is not None:
3193
remote_repo_url = urlutils.join(a_bzrdir.user_url, repo_path)
3194
url_diff = urlutils.relative_url(repository.user_url,
3197
raise AssertionError(
3198
'repository.user_url %r does not match URL from server '
3199
'response (%r + %r)'
3200
% (repository.user_url, a_bzrdir.user_url, repo_path))
3201
remote_repo = repository
2053
if response[2] == '':
2054
repo_bzrdir = a_bzrdir
3204
repo_bzrdir = a_bzrdir
3206
repo_bzrdir = RemoteBzrDir(
3207
a_bzrdir.root_transport.clone(repo_path), a_bzrdir._format,
3209
remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2056
repo_bzrdir = RemoteBzrDir(
2057
a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
2059
remote_repo = RemoteRepository(repo_bzrdir, repo_format)
3210
2060
remote_branch = RemoteBranch(a_bzrdir, remote_repo,
3211
format=format, setup_stacking=False, name=name)
3212
if append_revisions_only:
3213
remote_branch.set_append_revisions_only(append_revisions_only)
2061
format=format, setup_stacking=False)
3214
2062
# XXX: We know this is a new branch, so it must have revno 0, revid
3215
2063
# NULL_REVISION. Creating the branch locked would make this be unable
3216
2064
# to be wrong; here its simply very unlikely to be wrong. RBC 20090225
3235
2083
self._ensure_real()
3236
2084
return self._custom_format.supports_set_append_revisions_only()
3238
def _use_default_local_heads_to_fetch(self):
3239
# If the branch format is a metadir format *and* its heads_to_fetch
3240
# implementation is not overridden vs the base class, we can use the
3241
# base class logic rather than use the heads_to_fetch RPC. This is
3242
# usually cheaper in terms of net round trips, as the last-revision and
3243
# tags info fetched is cached and would be fetched anyway.
3245
if isinstance(self._custom_format, branch.BranchFormatMetadir):
3246
branch_class = self._custom_format._branch_class()
3247
heads_to_fetch_impl = branch_class.heads_to_fetch.im_func
3248
if heads_to_fetch_impl is branch.Branch.heads_to_fetch.im_func:
3253
class RemoteBranchStore(_mod_config.IniFileStore):
3254
"""Branch store which attempts to use HPSS calls to retrieve branch store.
3256
Note that this is specific to bzr-based formats.
3259
def __init__(self, branch):
3260
super(RemoteBranchStore, self).__init__()
3261
self.branch = branch
3263
self._real_store = None
3265
def external_url(self):
3266
return self.branch.user_url
3268
def _load_content(self):
3269
path = self.branch._remote_path()
3271
response, handler = self.branch._call_expecting_body(
3272
'Branch.get_config_file', path)
3273
except errors.UnknownSmartMethod:
3275
return self._real_store._load_content()
3276
if len(response) and response[0] != 'ok':
3277
raise errors.UnexpectedSmartServerResponse(response)
3278
return handler.read_body_bytes()
3280
def _save_content(self, content):
3281
path = self.branch._remote_path()
3283
response, handler = self.branch._call_with_body_bytes_expecting_body(
3284
'Branch.put_config_file', (path,
3285
self.branch._lock_token, self.branch._repo_lock_token),
3287
except errors.UnknownSmartMethod:
3289
return self._real_store._save_content(content)
3290
handler.cancel_read_body()
3291
if response != ('ok', ):
3292
raise errors.UnexpectedSmartServerResponse(response)
3294
def _ensure_real(self):
3295
self.branch._ensure_real()
3296
if self._real_store is None:
3297
self._real_store = _mod_config.BranchStore(self.branch)
3300
2087
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
3301
2088
"""Branch stored on a server accessed by HPSS RPC.
3843
2586
_override_hook_target=self, **kwargs)
3845
2588
@needs_read_lock
3846
def push(self, target, overwrite=False, stop_revision=None, lossy=False):
2589
def push(self, target, overwrite=False, stop_revision=None):
3847
2590
self._ensure_real()
3848
2591
return self._real_branch.push(
3849
target, overwrite=overwrite, stop_revision=stop_revision, lossy=lossy,
2592
target, overwrite=overwrite, stop_revision=stop_revision,
3850
2593
_override_hook_source_branch=self)
3852
2595
def is_locked(self):
3853
2596
return self._lock_count >= 1
3855
2598
@needs_read_lock
3856
def revision_id_to_dotted_revno(self, revision_id):
3857
"""Given a revision id, return its dotted revno.
3859
:return: a tuple like (1,) or (400,1,3).
3862
response = self._call('Branch.revision_id_to_revno',
3863
self._remote_path(), revision_id)
3864
except errors.UnknownSmartMethod:
3866
return self._real_branch.revision_id_to_dotted_revno(revision_id)
3867
if response[0] == 'ok':
3868
return tuple([int(x) for x in response[1:]])
3870
raise errors.UnexpectedSmartServerResponse(response)
3873
2599
def revision_id_to_revno(self, revision_id):
3874
"""Given a revision id on the branch mainline, return its revno.
3879
response = self._call('Branch.revision_id_to_revno',
3880
self._remote_path(), revision_id)
3881
except errors.UnknownSmartMethod:
3883
return self._real_branch.revision_id_to_revno(revision_id)
3884
if response[0] == 'ok':
3885
if len(response) == 2:
3886
return int(response[1])
3887
raise NoSuchRevision(self, revision_id)
3889
raise errors.UnexpectedSmartServerResponse(response)
2601
return self._real_branch.revision_id_to_revno(revision_id)
3891
2603
@needs_write_lock
3892
2604
def set_last_revision_info(self, revno, revision_id):
3893
2605
# XXX: These should be returned by the set_last_revision_info verb
3894
2606
old_revno, old_revid = self.last_revision_info()
3895
2607
self._run_pre_change_branch_tip_hooks(revno, revision_id)
3896
if not revision_id or not isinstance(revision_id, basestring):
3897
raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2608
revision_id = ensure_null(revision_id)
3899
2610
response = self._call('Branch.set_last_revision_info',
3900
2611
self._remote_path(), self._lock_token, self._repo_lock_token,
3929
2640
except errors.UnknownSmartMethod:
3930
2641
medium._remember_remote_is_before((1, 6))
3931
2642
self._clear_cached_state_of_remote_branch_only()
3932
graph = self.repository.get_graph()
3933
(last_revno, last_revid) = self.last_revision_info()
3934
known_revision_ids = [
3935
(last_revid, last_revno),
3936
(_mod_revision.NULL_REVISION, 0),
3938
if last_rev is not None:
3939
if not graph.is_ancestor(last_rev, revision_id):
3940
# our previous tip is not merged into stop_revision
3941
raise errors.DivergedBranches(self, other_branch)
3942
revno = graph.find_distance_to_null(revision_id, known_revision_ids)
3943
self.set_last_revision_info(revno, revision_id)
2643
self.set_revision_history(self._lefthand_history(revision_id,
2644
last_rev=last_rev,other_branch=other_branch))
3945
2646
def set_push_location(self, location):
3946
self._set_config_location('push_location', location)
3948
def heads_to_fetch(self):
3949
if self._format._use_default_local_heads_to_fetch():
3950
# We recognise this format, and its heads-to-fetch implementation
3951
# is the default one (tip + tags). In this case it's cheaper to
3952
# just use the default implementation rather than a special RPC as
3953
# the tip and tags data is cached.
3954
return branch.Branch.heads_to_fetch(self)
3955
medium = self._client._medium
3956
if medium._is_remote_before((2, 4)):
3957
return self._vfs_heads_to_fetch()
3959
return self._rpc_heads_to_fetch()
3960
except errors.UnknownSmartMethod:
3961
medium._remember_remote_is_before((2, 4))
3962
return self._vfs_heads_to_fetch()
3964
def _rpc_heads_to_fetch(self):
3965
response = self._call('Branch.heads_to_fetch', self._remote_path())
3966
if len(response) != 2:
3967
raise errors.UnexpectedSmartServerResponse(response)
3968
must_fetch, if_present_fetch = response
3969
return set(must_fetch), set(if_present_fetch)
3971
def _vfs_heads_to_fetch(self):
3972
2647
self._ensure_real()
3973
return self._real_branch.heads_to_fetch()
2648
return self._real_branch.set_push_location(location)
3976
2651
class RemoteConfig(object):
4041
2706
medium = self._branch._client._medium
4042
2707
if medium._is_remote_before((1, 14)):
4043
2708
return self._vfs_set_option(value, name, section)
4044
if isinstance(value, dict):
4045
if medium._is_remote_before((2, 2)):
4046
return self._vfs_set_option(value, name, section)
4047
return self._set_config_option_dict(value, name, section)
4049
return self._set_config_option(value, name, section)
4051
def _set_config_option(self, value, name, section):
4053
2710
path = self._branch._remote_path()
4054
2711
response = self._branch._client.call('Branch.set_config_option',
4055
2712
path, self._branch._lock_token, self._branch._repo_lock_token,
4056
2713
value.encode('utf8'), name, section or '')
4057
2714
except errors.UnknownSmartMethod:
4058
medium = self._branch._client._medium
4059
2715
medium._remember_remote_is_before((1, 14))
4060
2716
return self._vfs_set_option(value, name, section)
4061
2717
if response != ():
4062
2718
raise errors.UnexpectedSmartServerResponse(response)
4064
def _serialize_option_dict(self, option_dict):
4066
for key, value in option_dict.items():
4067
if isinstance(key, unicode):
4068
key = key.encode('utf8')
4069
if isinstance(value, unicode):
4070
value = value.encode('utf8')
4071
utf8_dict[key] = value
4072
return bencode.bencode(utf8_dict)
4074
def _set_config_option_dict(self, value, name, section):
4076
path = self._branch._remote_path()
4077
serialised_dict = self._serialize_option_dict(value)
4078
response = self._branch._client.call(
4079
'Branch.set_config_option_dict',
4080
path, self._branch._lock_token, self._branch._repo_lock_token,
4081
serialised_dict, name, section or '')
4082
except errors.UnknownSmartMethod:
4083
medium = self._branch._client._medium
4084
medium._remember_remote_is_before((2, 2))
4085
return self._vfs_set_option(value, name, section)
4087
raise errors.UnexpectedSmartServerResponse(response)
4089
2720
def _real_object(self):
4090
2721
self._branch._ensure_real()
4091
2722
return self._branch._real_branch
4177
2805
'Missing key %r in context %r', key_err.args[0], context)
4181
translator = error_translators.get(err.error_verb)
4185
raise translator(err, find, get_path)
4187
translator = no_context_error_translators.get(err.error_verb)
4189
raise errors.UnknownErrorFromSmartServer(err)
4191
raise translator(err)
4194
error_translators.register('NoSuchRevision',
4195
lambda err, find, get_path: NoSuchRevision(
4196
find('branch'), err.error_args[0]))
4197
error_translators.register('nosuchrevision',
4198
lambda err, find, get_path: NoSuchRevision(
4199
find('repository'), err.error_args[0]))
4201
def _translate_nobranch_error(err, find, get_path):
4202
if len(err.error_args) >= 1:
4203
extra = err.error_args[0]
4206
return errors.NotBranchError(path=find('bzrdir').root_transport.base,
4209
error_translators.register('nobranch', _translate_nobranch_error)
4210
error_translators.register('norepository',
4211
lambda err, find, get_path: errors.NoRepositoryPresent(
4213
error_translators.register('UnlockableTransport',
4214
lambda err, find, get_path: errors.UnlockableTransport(
4215
find('bzrdir').root_transport))
4216
error_translators.register('TokenMismatch',
4217
lambda err, find, get_path: errors.TokenMismatch(
4218
find('token'), '(remote token)'))
4219
error_translators.register('Diverged',
4220
lambda err, find, get_path: errors.DivergedBranches(
4221
find('branch'), find('other_branch')))
4222
error_translators.register('NotStacked',
4223
lambda err, find, get_path: errors.NotStacked(branch=find('branch')))
4225
def _translate_PermissionDenied(err, find, get_path):
4227
if len(err.error_args) >= 2:
4228
extra = err.error_args[1]
4231
return errors.PermissionDenied(path, extra=extra)
4233
error_translators.register('PermissionDenied', _translate_PermissionDenied)
4234
error_translators.register('ReadError',
4235
lambda err, find, get_path: errors.ReadError(get_path()))
4236
error_translators.register('NoSuchFile',
4237
lambda err, find, get_path: errors.NoSuchFile(get_path()))
4238
error_translators.register('TokenLockingNotSupported',
4239
lambda err, find, get_path: errors.TokenLockingNotSupported(
4240
find('repository')))
4241
error_translators.register('UnsuspendableWriteGroup',
4242
lambda err, find, get_path: errors.UnsuspendableWriteGroup(
4243
repository=find('repository')))
4244
error_translators.register('UnresumableWriteGroup',
4245
lambda err, find, get_path: errors.UnresumableWriteGroup(
4246
repository=find('repository'), write_groups=err.error_args[0],
4247
reason=err.error_args[1]))
4248
no_context_error_translators.register('IncompatibleRepositories',
4249
lambda err: errors.IncompatibleRepositories(
4250
err.error_args[0], err.error_args[1], err.error_args[2]))
4251
no_context_error_translators.register('LockContention',
4252
lambda err: errors.LockContention('(remote lock)'))
4253
no_context_error_translators.register('LockFailed',
4254
lambda err: errors.LockFailed(err.error_args[0], err.error_args[1]))
4255
no_context_error_translators.register('TipChangeRejected',
4256
lambda err: errors.TipChangeRejected(err.error_args[0].decode('utf8')))
4257
no_context_error_translators.register('UnstackableBranchFormat',
4258
lambda err: errors.UnstackableBranchFormat(*err.error_args))
4259
no_context_error_translators.register('UnstackableRepositoryFormat',
4260
lambda err: errors.UnstackableRepositoryFormat(*err.error_args))
4261
no_context_error_translators.register('FileExists',
4262
lambda err: errors.FileExists(err.error_args[0]))
4263
no_context_error_translators.register('DirectoryNotEmpty',
4264
lambda err: errors.DirectoryNotEmpty(err.error_args[0]))
4266
def _translate_short_readv_error(err):
4267
args = err.error_args
4268
return errors.ShortReadvError(args[0], int(args[1]), int(args[2]),
4271
no_context_error_translators.register('ShortReadvError',
4272
_translate_short_readv_error)
4274
def _translate_unicode_error(err):
2808
if err.error_verb == 'IncompatibleRepositories':
2809
raise errors.IncompatibleRepositories(err.error_args[0],
2810
err.error_args[1], err.error_args[2])
2811
elif err.error_verb == 'NoSuchRevision':
2812
raise NoSuchRevision(find('branch'), err.error_args[0])
2813
elif err.error_verb == 'nosuchrevision':
2814
raise NoSuchRevision(find('repository'), err.error_args[0])
2815
elif err.error_tuple == ('nobranch',):
2816
raise errors.NotBranchError(path=find('bzrdir').root_transport.base)
2817
elif err.error_verb == 'norepository':
2818
raise errors.NoRepositoryPresent(find('bzrdir'))
2819
elif err.error_verb == 'LockContention':
2820
raise errors.LockContention('(remote lock)')
2821
elif err.error_verb == 'UnlockableTransport':
2822
raise errors.UnlockableTransport(find('bzrdir').root_transport)
2823
elif err.error_verb == 'LockFailed':
2824
raise errors.LockFailed(err.error_args[0], err.error_args[1])
2825
elif err.error_verb == 'TokenMismatch':
2826
raise errors.TokenMismatch(find('token'), '(remote token)')
2827
elif err.error_verb == 'Diverged':
2828
raise errors.DivergedBranches(find('branch'), find('other_branch'))
2829
elif err.error_verb == 'TipChangeRejected':
2830
raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
2831
elif err.error_verb == 'UnstackableBranchFormat':
2832
raise errors.UnstackableBranchFormat(*err.error_args)
2833
elif err.error_verb == 'UnstackableRepositoryFormat':
2834
raise errors.UnstackableRepositoryFormat(*err.error_args)
2835
elif err.error_verb == 'NotStacked':
2836
raise errors.NotStacked(branch=find('branch'))
2837
elif err.error_verb == 'PermissionDenied':
2839
if len(err.error_args) >= 2:
2840
extra = err.error_args[1]
2843
raise errors.PermissionDenied(path, extra=extra)
2844
elif err.error_verb == 'ReadError':
2846
raise errors.ReadError(path)
2847
elif err.error_verb == 'NoSuchFile':
2849
raise errors.NoSuchFile(path)
2850
elif err.error_verb == 'FileExists':
2851
raise errors.FileExists(err.error_args[0])
2852
elif err.error_verb == 'DirectoryNotEmpty':
2853
raise errors.DirectoryNotEmpty(err.error_args[0])
2854
elif err.error_verb == 'ShortReadvError':
2855
args = err.error_args
2856
raise errors.ShortReadvError(
2857
args[0], int(args[1]), int(args[2]), int(args[3]))
2858
elif err.error_verb in ('UnicodeEncodeError', 'UnicodeDecodeError'):
4275
2859
encoding = str(err.error_args[0]) # encoding must always be a string
4276
2860
val = err.error_args[1]
4277
2861
start = int(err.error_args[2])
added
removed
bzrlib/remote.py
