75
65
method, args, body_bytes)
76
66
except errors.ErrorFromSmartServer, err:
77
67
self._translate_error(err, **err_context)
80
def response_tuple_to_repo_format(response):
81
"""Convert a response tuple describing a repository format to a format."""
82
format = RemoteRepositoryFormat()
83
format._rich_root_data = (response[0] == 'yes')
84
format._supports_tree_reference = (response[1] == 'yes')
85
format._supports_external_lookups = (response[2] == 'yes')
86
format._network_name = response[3]
90
69
# Note: RemoteBzrDirFormat is in bzrdir.py
92
71
class RemoteBzrDir(BzrDir, _RpcHelper):
93
72
"""Control directory on a remote server, accessed via bzr:// or similar."""
95
def __init__(self, transport, format, _client=None, _force_probe=False):
74
def __init__(self, transport, _client=None):
96
75
"""Construct a RemoteBzrDir.
98
77
:param _client: Private parameter for testing. Disables probing and the
99
78
use of a real bzrdir.
101
BzrDir.__init__(self, transport, format)
80
BzrDir.__init__(self, transport, RemoteBzrDirFormat())
102
81
# this object holds a delegated bzrdir that uses file-level operations
103
82
# to talk to the other side
104
83
self._real_bzrdir = None
105
self._has_working_tree = None
106
# 1-shot cache for the call pattern 'create_branch; open_branch' - see
107
# create_branch for details.
108
self._next_open_branch_result = None
110
85
if _client is None:
111
86
medium = transport.get_smart_medium()
112
87
self._client = client._SmartClient(medium)
114
89
self._client = _client
121
return '%s(%r)' % (self.__class__.__name__, self._client)
123
def _probe_bzrdir(self):
124
medium = self._client._medium
125
92
path = self._path_for_remote_call(self._client)
126
if medium._is_remote_before((2, 1)):
130
self._rpc_open_2_1(path)
132
except errors.UnknownSmartMethod:
133
medium._remember_remote_is_before((2, 1))
136
def _rpc_open_2_1(self, path):
137
response = self._call('BzrDir.open_2.1', path)
138
if response == ('no',):
139
raise errors.NotBranchError(path=self.root_transport.base)
140
elif response[0] == 'yes':
141
if response[1] == 'yes':
142
self._has_working_tree = True
143
elif response[1] == 'no':
144
self._has_working_tree = False
146
raise errors.UnexpectedSmartServerResponse(response)
148
raise errors.UnexpectedSmartServerResponse(response)
150
def _rpc_open(self, path):
151
93
response = self._call('BzrDir.open', path)
152
94
if response not in [('yes',), ('no',)]:
153
95
raise errors.UnexpectedSmartServerResponse(response)
154
96
if response == ('no',):
155
raise errors.NotBranchError(path=self.root_transport.base)
97
raise errors.NotBranchError(path=transport.base)
157
99
def _ensure_real(self):
158
100
"""Ensure that there is a _real_bzrdir set.
160
102
Used before calls to self._real_bzrdir.
162
104
if not self._real_bzrdir:
163
if 'hpssvfs' in debug.debug_flags:
165
warning('VFS BzrDir access triggered\n%s',
166
''.join(traceback.format_stack()))
167
105
self._real_bzrdir = BzrDir.open_from_transport(
168
106
self.root_transport, _server_formats=False)
169
self._format._network_name = \
170
self._real_bzrdir._format.network_name()
172
108
def _translate_error(self, err, **context):
173
109
_translate_error(err, bzrdir=self, **context)
175
def break_lock(self):
176
# Prevent aliasing problems in the next_open_branch_result cache.
177
# See create_branch for rationale.
178
self._next_open_branch_result = None
179
return BzrDir.break_lock(self)
181
def _vfs_cloning_metadir(self, require_stacking=False):
111
def cloning_metadir(self, stacked=False):
182
112
self._ensure_real()
183
return self._real_bzrdir.cloning_metadir(
184
require_stacking=require_stacking)
186
def cloning_metadir(self, require_stacking=False):
187
medium = self._client._medium
188
if medium._is_remote_before((1, 13)):
189
return self._vfs_cloning_metadir(require_stacking=require_stacking)
190
verb = 'BzrDir.cloning_metadir'
195
path = self._path_for_remote_call(self._client)
197
response = self._call(verb, path, stacking)
198
except errors.UnknownSmartMethod:
199
medium._remember_remote_is_before((1, 13))
200
return self._vfs_cloning_metadir(require_stacking=require_stacking)
201
except errors.UnknownErrorFromSmartServer, err:
202
if err.error_tuple != ('BranchReference',):
204
# We need to resolve the branch reference to determine the
205
# cloning_metadir. This causes unnecessary RPCs to open the
206
# referenced branch (and bzrdir, etc) but only when the caller
207
# didn't already resolve the branch reference.
208
referenced_branch = self.open_branch()
209
return referenced_branch.bzrdir.cloning_metadir()
210
if len(response) != 3:
211
raise errors.UnexpectedSmartServerResponse(response)
212
control_name, repo_name, branch_info = response
213
if len(branch_info) != 2:
214
raise errors.UnexpectedSmartServerResponse(response)
215
branch_ref, branch_name = branch_info
216
format = bzrdir.network_format_registry.get(control_name)
218
format.repository_format = repository.network_format_registry.get(
220
if branch_ref == 'ref':
221
# XXX: we need possible_transports here to avoid reopening the
222
# connection to the referenced location
223
ref_bzrdir = BzrDir.open(branch_name)
224
branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
225
format.set_branch_format(branch_format)
226
elif branch_ref == 'branch':
228
format.set_branch_format(
229
branch.network_format_registry.get(branch_name))
231
raise errors.UnexpectedSmartServerResponse(response)
113
return self._real_bzrdir.cloning_metadir(stacked)
234
115
def create_repository(self, shared=False):
235
# as per meta1 formats - just delegate to the format object which may
237
result = self._format.repository_format.initialize(self, shared)
238
if not isinstance(result, RemoteRepository):
239
return self.open_repository()
117
self._real_bzrdir.create_repository(shared=shared)
118
return self.open_repository()
243
120
def destroy_repository(self):
244
121
"""See BzrDir.destroy_repository"""
245
122
self._ensure_real()
246
123
self._real_bzrdir.destroy_repository()
248
def create_branch(self, name=None):
249
# as per meta1 formats - just delegate to the format object which may
251
real_branch = self._format.get_branch_format().initialize(self,
253
if not isinstance(real_branch, RemoteBranch):
254
result = RemoteBranch(self, self.find_repository(), real_branch,
258
# BzrDir.clone_on_transport() uses the result of create_branch but does
259
# not return it to its callers; we save approximately 8% of our round
260
# trips by handing the branch we created back to the first caller to
261
# open_branch rather than probing anew. Long term we need a API in
262
# bzrdir that doesn't discard result objects (like result_branch).
264
self._next_open_branch_result = result
125
def create_branch(self):
127
real_branch = self._real_bzrdir.create_branch()
128
return RemoteBranch(self, self.find_repository(), real_branch)
267
def destroy_branch(self, name=None):
130
def destroy_branch(self):
268
131
"""See BzrDir.destroy_branch"""
269
132
self._ensure_real()
270
self._real_bzrdir.destroy_branch(name=name)
271
self._next_open_branch_result = None
133
self._real_bzrdir.destroy_branch()
273
135
def create_workingtree(self, revision_id=None, from_branch=None):
274
136
raise errors.NotLocalUrl(self.transport.base)
284
146
def get_branch_reference(self):
285
147
"""See BzrDir.get_branch_reference()."""
286
response = self._get_branch_reference()
287
if response[0] == 'ref':
148
path = self._path_for_remote_call(self._client)
149
response = self._call('BzrDir.open_branch', path)
150
if response[0] == 'ok':
151
if response[1] == '':
152
# branch at this location.
155
# a branch reference, use the existing BranchReference logic.
292
def _get_branch_reference(self):
293
path = self._path_for_remote_call(self._client)
294
medium = self._client._medium
296
('BzrDir.open_branchV3', (2, 1)),
297
('BzrDir.open_branchV2', (1, 13)),
298
('BzrDir.open_branch', None),
300
for verb, required_version in candidate_calls:
301
if required_version and medium._is_remote_before(required_version):
304
response = self._call(verb, path)
305
except errors.UnknownSmartMethod:
306
if required_version is None:
308
medium._remember_remote_is_before(required_version)
311
if verb == 'BzrDir.open_branch':
312
if response[0] != 'ok':
313
raise errors.UnexpectedSmartServerResponse(response)
314
if response[1] != '':
315
return ('ref', response[1])
317
return ('branch', '')
318
if response[0] not in ('ref', 'branch'):
319
158
raise errors.UnexpectedSmartServerResponse(response)
322
160
def _get_tree_branch(self):
323
161
"""See BzrDir._get_tree_branch()."""
324
162
return None, self.open_branch()
326
def open_branch(self, name=None, unsupported=False,
327
ignore_fallbacks=False):
164
def open_branch(self, _unsupported=False):
329
166
raise NotImplementedError('unsupported flag support not implemented yet.')
330
if self._next_open_branch_result is not None:
331
# See create_branch for details.
332
result = self._next_open_branch_result
333
self._next_open_branch_result = None
335
response = self._get_branch_reference()
336
if response[0] == 'ref':
167
reference_url = self.get_branch_reference()
168
if reference_url is None:
169
# branch at this location.
170
return RemoteBranch(self, self.find_repository())
337
172
# a branch reference, use the existing BranchReference logic.
338
173
format = BranchReferenceFormat()
339
return format.open(self, name=name, _found=True,
340
location=response[1], ignore_fallbacks=ignore_fallbacks)
341
branch_format_name = response[1]
342
if not branch_format_name:
343
branch_format_name = None
344
format = RemoteBranchFormat(network_name=branch_format_name)
345
return RemoteBranch(self, self.find_repository(), format=format,
346
setup_stacking=not ignore_fallbacks, name=name)
348
def _open_repo_v1(self, path):
349
verb = 'BzrDir.find_repository'
350
response = self._call(verb, path)
351
if response[0] != 'ok':
352
raise errors.UnexpectedSmartServerResponse(response)
353
# servers that only support the v1 method don't support external
356
repo = self._real_bzrdir.open_repository()
357
response = response + ('no', repo._format.network_name())
358
return response, repo
360
def _open_repo_v2(self, path):
174
return format.open(self, _found=True, location=reference_url)
176
def open_repository(self):
177
path = self._path_for_remote_call(self._client)
361
178
verb = 'BzrDir.find_repositoryV2'
362
response = self._call(verb, path)
363
if response[0] != 'ok':
364
raise errors.UnexpectedSmartServerResponse(response)
366
repo = self._real_bzrdir.open_repository()
367
response = response + (repo._format.network_name(),)
368
return response, repo
370
def _open_repo_v3(self, path):
371
verb = 'BzrDir.find_repositoryV3'
372
medium = self._client._medium
373
if medium._is_remote_before((1, 13)):
374
raise errors.UnknownSmartMethod(verb)
376
180
response = self._call(verb, path)
377
181
except errors.UnknownSmartMethod:
378
medium._remember_remote_is_before((1, 13))
380
if response[0] != 'ok':
381
raise errors.UnexpectedSmartServerResponse(response)
382
return response, None
384
def open_repository(self):
385
path = self._path_for_remote_call(self._client)
387
for probe in [self._open_repo_v3, self._open_repo_v2,
390
response, real_repo = probe(path)
392
except errors.UnknownSmartMethod:
395
raise errors.UnknownSmartMethod('BzrDir.find_repository{3,2,}')
396
if response[0] != 'ok':
397
raise errors.UnexpectedSmartServerResponse(response)
398
if len(response) != 6:
182
verb = 'BzrDir.find_repository'
183
response = self._call(verb, path)
184
if response[0] != 'ok':
185
raise errors.UnexpectedSmartServerResponse(response)
186
if verb == 'BzrDir.find_repository':
187
# servers that don't support the V2 method don't support external
189
response = response + ('no', )
190
if not (len(response) == 5):
399
191
raise SmartProtocolError('incorrect response length %s' % (response,))
400
192
if response[1] == '':
401
# repo is at this dir.
402
format = response_tuple_to_repo_format(response[2:])
193
format = RemoteRepositoryFormat()
194
format.rich_root_data = (response[2] == 'yes')
195
format.supports_tree_reference = (response[3] == 'yes')
196
# No wire format to check this yet.
197
format.supports_external_lookups = (response[4] == 'yes')
403
198
# Used to support creating a real format instance when needed.
404
199
format._creating_bzrdir = self
405
remote_repo = RemoteRepository(self, format)
406
format._creating_repo = remote_repo
407
if real_repo is not None:
408
remote_repo._set_real_repository(real_repo)
200
return RemoteRepository(self, format)
411
202
raise errors.NoRepositoryPresent(self)
413
def has_workingtree(self):
414
if self._has_working_tree is None:
416
self._has_working_tree = self._real_bzrdir.has_workingtree()
417
return self._has_working_tree
419
204
def open_workingtree(self, recommend_upgrade=True):
420
if self.has_workingtree():
206
if self._real_bzrdir.has_workingtree():
421
207
raise errors.NotLocalUrl(self.root_transport)
423
209
raise errors.NoWorkingTree(self.root_transport.base)
470
254
the attributes rich_root_data and supports_tree_reference are set
471
255
on a per instance basis, and are not set (and should not be) at
474
:ivar _custom_format: If set, a specific concrete repository format that
475
will be used when initializing a repository with this
476
RemoteRepositoryFormat.
477
:ivar _creating_repo: If set, the repository object that this
478
RemoteRepositoryFormat was created for: it can be called into
479
to obtain data like the network name.
482
259
_matchingbzrdir = RemoteBzrDirFormat()
485
repository.RepositoryFormat.__init__(self)
486
self._custom_format = None
487
self._network_name = None
488
self._creating_bzrdir = None
489
self._supports_chks = None
490
self._supports_external_lookups = None
491
self._supports_tree_reference = None
492
self._rich_root_data = None
495
return "%s(_network_name=%r)" % (self.__class__.__name__,
499
def fast_deltas(self):
501
return self._custom_format.fast_deltas
504
def rich_root_data(self):
505
if self._rich_root_data is None:
507
self._rich_root_data = self._custom_format.rich_root_data
508
return self._rich_root_data
511
def supports_chks(self):
512
if self._supports_chks is None:
514
self._supports_chks = self._custom_format.supports_chks
515
return self._supports_chks
518
def supports_external_lookups(self):
519
if self._supports_external_lookups is None:
521
self._supports_external_lookups = \
522
self._custom_format.supports_external_lookups
523
return self._supports_external_lookups
526
def supports_tree_reference(self):
527
if self._supports_tree_reference is None:
529
self._supports_tree_reference = \
530
self._custom_format.supports_tree_reference
531
return self._supports_tree_reference
533
def _vfs_initialize(self, a_bzrdir, shared):
534
"""Helper for common code in initialize."""
535
if self._custom_format:
536
# Custom format requested
537
result = self._custom_format.initialize(a_bzrdir, shared=shared)
538
elif self._creating_bzrdir is not None:
539
# Use the format that the repository we were created to back
261
def initialize(self, a_bzrdir, shared=False):
262
if not isinstance(a_bzrdir, RemoteBzrDir):
541
263
prior_repo = self._creating_bzrdir.open_repository()
542
264
prior_repo._ensure_real()
543
result = prior_repo._real_repository._format.initialize(
265
return prior_repo._real_repository._format.initialize(
544
266
a_bzrdir, shared=shared)
546
# assume that a_bzr is a RemoteBzrDir but the smart server didn't
547
# support remote initialization.
548
# We delegate to a real object at this point (as RemoteBzrDir
549
# delegate to the repository format which would lead to infinite
550
# recursion if we just called a_bzrdir.create_repository.
551
a_bzrdir._ensure_real()
552
result = a_bzrdir._real_bzrdir.create_repository(shared=shared)
553
if not isinstance(result, RemoteRepository):
554
return self.open(a_bzrdir)
558
def initialize(self, a_bzrdir, shared=False):
559
# Being asked to create on a non RemoteBzrDir:
560
if not isinstance(a_bzrdir, RemoteBzrDir):
561
return self._vfs_initialize(a_bzrdir, shared)
562
medium = a_bzrdir._client._medium
563
if medium._is_remote_before((1, 13)):
564
return self._vfs_initialize(a_bzrdir, shared)
565
# Creating on a remote bzr dir.
566
# 1) get the network name to use.
567
if self._custom_format:
568
network_name = self._custom_format.network_name()
569
elif self._network_name:
570
network_name = self._network_name
572
# Select the current bzrlib default and ask for that.
573
reference_bzrdir_format = bzrdir.format_registry.get('default')()
574
reference_format = reference_bzrdir_format.repository_format
575
network_name = reference_format.network_name()
576
# 2) try direct creation via RPC
577
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
578
verb = 'BzrDir.create_repository'
584
response = a_bzrdir._call(verb, path, network_name, shared_str)
585
except errors.UnknownSmartMethod:
586
# Fallback - use vfs methods
587
medium._remember_remote_is_before((1, 13))
588
return self._vfs_initialize(a_bzrdir, shared)
590
# Turn the response into a RemoteRepository object.
591
format = response_tuple_to_repo_format(response[1:])
592
# Used to support creating a real format instance when needed.
593
format._creating_bzrdir = a_bzrdir
594
remote_repo = RemoteRepository(a_bzrdir, format)
595
format._creating_repo = remote_repo
267
return a_bzrdir.create_repository(shared=shared)
598
269
def open(self, a_bzrdir):
599
270
if not isinstance(a_bzrdir, RemoteBzrDir):
600
271
raise AssertionError('%r is not a RemoteBzrDir' % (a_bzrdir,))
601
272
return a_bzrdir.open_repository()
603
def _ensure_real(self):
604
if self._custom_format is None:
605
self._custom_format = repository.network_format_registry.get(
609
def _fetch_order(self):
611
return self._custom_format._fetch_order
614
def _fetch_uses_deltas(self):
616
return self._custom_format._fetch_uses_deltas
619
def _fetch_reconcile(self):
621
return self._custom_format._fetch_reconcile
623
274
def get_format_description(self):
625
return 'Remote: ' + self._custom_format.get_format_description()
275
return 'bzr remote repository'
627
277
def __eq__(self, other):
628
return self.__class__ is other.__class__
630
def network_name(self):
631
if self._network_name:
632
return self._network_name
633
self._creating_repo._ensure_real()
634
return self._creating_repo._real_repository._format.network_name()
637
def pack_compresses(self):
639
return self._custom_format.pack_compresses
642
def _serializer(self):
644
return self._custom_format._serializer
647
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
648
bzrdir.ControlComponent):
278
return self.__class__ == other.__class__
280
def check_conversion_target(self, target_format):
281
if self.rich_root_data and not target_format.rich_root_data:
282
raise errors.BadConversionTarget(
283
'Does not support rich root data.', target_format)
284
if (self.supports_tree_reference and
285
not getattr(target_format, 'supports_tree_reference', False)):
286
raise errors.BadConversionTarget(
287
'Does not support nested trees', target_format)
290
class RemoteRepository(_RpcHelper):
649
291
"""Repository accessed over rpc.
651
293
For the moment most operations are performed using local transport-backed
745
365
self._ensure_real()
746
366
return self._real_repository.commit_write_group()
748
def resume_write_group(self, tokens):
750
return self._real_repository.resume_write_group(tokens)
752
def suspend_write_group(self):
754
return self._real_repository.suspend_write_group()
756
def get_missing_parent_inventories(self, check_for_missing_texts=True):
758
return self._real_repository.get_missing_parent_inventories(
759
check_for_missing_texts=check_for_missing_texts)
761
def _get_rev_id_for_revno_vfs(self, revno, known_pair):
763
return self._real_repository.get_rev_id_for_revno(
766
def get_rev_id_for_revno(self, revno, known_pair):
767
"""See Repository.get_rev_id_for_revno."""
768
path = self.bzrdir._path_for_remote_call(self._client)
770
if self._client._medium._is_remote_before((1, 17)):
771
return self._get_rev_id_for_revno_vfs(revno, known_pair)
772
response = self._call(
773
'Repository.get_rev_id_for_revno', path, revno, known_pair)
774
except errors.UnknownSmartMethod:
775
self._client._medium._remember_remote_is_before((1, 17))
776
return self._get_rev_id_for_revno_vfs(revno, known_pair)
777
if response[0] == 'ok':
778
return True, response[1]
779
elif response[0] == 'history-incomplete':
780
known_pair = response[1:3]
781
for fallback in self._fallback_repositories:
782
found, result = fallback.get_rev_id_for_revno(revno, known_pair)
787
# Not found in any fallbacks
788
return False, known_pair
790
raise errors.UnexpectedSmartServerResponse(response)
792
368
def _ensure_real(self):
793
369
"""Ensure that there is a _real_repository set.
795
371
Used before calls to self._real_repository.
797
Note that _ensure_real causes many roundtrips to the server which are
798
not desirable, and prevents the use of smart one-roundtrip RPC's to
799
perform complex operations (such as accessing parent data, streaming
800
revisions etc). Adding calls to _ensure_real should only be done when
801
bringing up new functionality, adding fallbacks for smart methods that
802
require a fallback path, and never to replace an existing smart method
803
invocation. If in doubt chat to the bzr network team.
805
373
if self._real_repository is None:
806
if 'hpssvfs' in debug.debug_flags:
808
warning('VFS Repository access triggered\n%s',
809
''.join(traceback.format_stack()))
810
self._unstacked_provider.missing_keys.clear()
811
374
self.bzrdir._ensure_real()
812
375
self._set_real_repository(
813
376
self.bzrdir._real_bzrdir.open_repository())
862
430
for line in lines:
863
431
d = tuple(line.split())
864
432
revision_graph[d[0]] = d[1:]
866
434
return revision_graph
869
"""See Repository._get_sink()."""
870
return RemoteStreamSink(self)
872
def _get_source(self, to_format):
873
"""Return a source for streaming from this repository."""
874
return RemoteStreamSource(self, to_format)
877
436
def has_revision(self, revision_id):
878
"""True if this repository has a copy of the revision."""
879
# Copy of bzrlib.repository.Repository.has_revision
880
return revision_id in self.has_revisions((revision_id,))
437
"""See Repository.has_revision()."""
438
if revision_id == NULL_REVISION:
439
# The null revision is always present.
441
path = self.bzrdir._path_for_remote_call(self._client)
442
response = self._call('Repository.has_revision', path, revision_id)
443
if response[0] not in ('yes', 'no'):
444
raise errors.UnexpectedSmartServerResponse(response)
445
if response[0] == 'yes':
447
for fallback_repo in self._fallback_repositories:
448
if fallback_repo.has_revision(revision_id):
883
452
def has_revisions(self, revision_ids):
884
"""Probe to find out the presence of multiple revisions.
886
:param revision_ids: An iterable of revision_ids.
887
:return: A set of the revision_ids that were present.
889
# Copy of bzrlib.repository.Repository.has_revisions
890
parent_map = self.get_parent_map(revision_ids)
891
result = set(parent_map)
892
if _mod_revision.NULL_REVISION in revision_ids:
893
result.add(_mod_revision.NULL_REVISION)
453
"""See Repository.has_revisions()."""
454
# FIXME: This does many roundtrips, particularly when there are
455
# fallback repositories. -- mbp 20080905
457
for revision_id in revision_ids:
458
if self.has_revision(revision_id):
459
result.add(revision_id)
896
def _has_same_fallbacks(self, other_repo):
897
"""Returns true if the repositories have the same fallbacks."""
898
# XXX: copied from Repository; it should be unified into a base class
899
# <https://bugs.edge.launchpad.net/bzr/+bug/401622>
900
my_fb = self._fallback_repositories
901
other_fb = other_repo._fallback_repositories
902
if len(my_fb) != len(other_fb):
904
for f, g in zip(my_fb, other_fb):
905
if not f.has_same_location(g):
909
462
def has_same_location(self, other):
910
# TODO: Move to RepositoryBase and unify with the regular Repository
911
# one; unfortunately the tests rely on slightly different behaviour at
912
# present -- mbp 20090710
913
return (self.__class__ is other.__class__ and
463
return (self.__class__ == other.__class__ and
914
464
self.bzrdir.transport.base == other.bzrdir.transport.base)
916
466
def get_graph(self, other_repository=None):
917
467
"""Return the graph for this repository format"""
918
parents_provider = self._make_parents_provider(other_repository)
468
parents_provider = self
469
if (other_repository is not None and
470
other_repository.bzrdir.transport.base !=
471
self.bzrdir.transport.base):
472
parents_provider = graph._StackedParentsProvider(
473
[parents_provider, other_repository._make_parents_provider()])
919
474
return graph.Graph(parents_provider)
922
def get_known_graph_ancestry(self, revision_ids):
923
"""Return the known graph for a set of revision ids and their ancestors.
925
st = static_tuple.StaticTuple
926
revision_keys = [st(r_id).intern() for r_id in revision_ids]
927
known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
928
return graph.GraphThunkIdsToKeys(known_graph)
930
476
def gather_stats(self, revid=None, committers=None):
931
477
"""See Repository.gather_stats()."""
932
478
path = self.bzrdir._path_for_remote_call(self._client)
1234
736
def add_fallback_repository(self, repository):
1235
737
"""Add a repository to use for looking up data not held locally.
1237
739
:param repository: A repository.
1239
if not self._format.supports_external_lookups:
1240
raise errors.UnstackableRepositoryFormat(
1241
self._format.network_name(), self.base)
741
# XXX: At the moment the RemoteRepository will allow fallbacks
742
# unconditionally - however, a _real_repository will usually exist,
743
# and may raise an error if it's not accommodated by the underlying
744
# format. Eventually we should check when opening the repository
745
# whether it's willing to allow them or not.
1242
747
# We need to accumulate additional repositories here, to pass them in
1243
748
# on various RPC's.
1245
if self.is_locked():
1246
# We will call fallback.unlock() when we transition to the unlocked
1247
# state, so always add a lock here. If a caller passes us a locked
1248
# repository, they are responsible for unlocking it later.
1249
repository.lock_read()
1250
self._check_fallback_repository(repository)
1251
749
self._fallback_repositories.append(repository)
1252
# If self._real_repository was parameterised already (e.g. because a
1253
# _real_branch had its get_stacked_on_url method called), then the
1254
# repository to be added may already be in the _real_repositories list.
1255
if self._real_repository is not None:
1256
fallback_locations = [repo.user_url for repo in
1257
self._real_repository._fallback_repositories]
1258
if repository.user_url not in fallback_locations:
1259
self._real_repository.add_fallback_repository(repository)
1261
def _check_fallback_repository(self, repository):
1262
"""Check that this repository can fallback to repository safely.
1264
Raise an error if not.
1266
:param repository: A repository to fallback to.
1268
return _mod_repository.InterRepository._assert_same_model(
750
# They are also seen by the fallback repository. If it doesn't exist
751
# yet they'll be added then. This implicitly copies them.
1271
754
def add_inventory(self, revid, inv, parents):
1272
755
self._ensure_real()
1273
756
return self._real_repository.add_inventory(revid, inv, parents)
1275
def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1276
parents, basis_inv=None, propagate_caches=False):
1278
return self._real_repository.add_inventory_by_delta(basis_revision_id,
1279
delta, new_revision_id, parents, basis_inv=basis_inv,
1280
propagate_caches=propagate_caches)
1282
758
def add_revision(self, rev_id, rev, inv=None, config=None):
1283
759
self._ensure_real()
1284
760
return self._real_repository.add_revision(
1350
812
return repository.InterRepository.get(
1351
813
other, self).search_missing_revision_ids(revision_id, find_ghosts)
1353
def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
1355
# No base implementation to use as RemoteRepository is not a subclass
1356
# of Repository; so this is a copy of Repository.fetch().
1357
if fetch_spec is not None and revision_id is not None:
1358
raise AssertionError(
1359
"fetch_spec and revision_id are mutually exclusive.")
1360
if self.is_in_write_group():
1361
raise errors.InternalBzrError(
1362
"May not fetch while in a write group.")
1363
# fast path same-url fetch operations
1364
if (self.has_same_location(source)
1365
and fetch_spec is None
1366
and self._has_same_fallbacks(source)):
815
def fetch(self, source, revision_id=None, pb=None, find_ghosts=False):
816
# Not delegated to _real_repository so that InterRepository.get has a
817
# chance to find an InterRepository specialised for RemoteRepository.
818
if self.has_same_location(source):
1367
819
# check that last_revision is in 'from' and then return a
1369
821
if (revision_id is not None and
1370
822
not revision.is_null(revision_id)):
1371
823
self.get_revision(revision_id)
1373
# if there is no specific appropriate InterRepository, this will get
1374
# the InterRepository base class, which raises an
1375
# IncompatibleRepositories when asked to fetch.
1376
825
inter = repository.InterRepository.get(source, self)
1377
return inter.fetch(revision_id=revision_id, pb=pb,
1378
find_ghosts=find_ghosts, fetch_spec=fetch_spec)
827
return inter.fetch(revision_id=revision_id, pb=pb, find_ghosts=find_ghosts)
828
except NotImplementedError:
829
raise errors.IncompatibleRepositories(source, self)
1380
831
def create_bundle(self, target, base, fileobj, format=None):
1381
832
self._ensure_real()
1394
845
self._ensure_real()
1395
846
return self._real_repository._get_versioned_file_checker(
1396
847
revisions, revision_versions_cache)
1398
849
def iter_files_bytes(self, desired_files):
1399
850
"""See Repository.iter_file_bytes.
1401
852
self._ensure_real()
1402
853
return self._real_repository.iter_files_bytes(desired_files)
1404
def get_parent_map(self, revision_ids):
856
def _fetch_order(self):
857
"""Decorate the real repository for now.
859
In the long term getting this back from the remote repository as part
860
of open would be more efficient.
863
return self._real_repository._fetch_order
866
def _fetch_uses_deltas(self):
867
"""Decorate the real repository for now.
869
In the long term getting this back from the remote repository as part
870
of open would be more efficient.
873
return self._real_repository._fetch_uses_deltas
876
def _fetch_reconcile(self):
877
"""Decorate the real repository for now.
879
In the long term getting this back from the remote repository as part
880
of open would be more efficient.
883
return self._real_repository._fetch_reconcile
885
def get_parent_map(self, keys):
1405
886
"""See bzrlib.Graph.get_parent_map()."""
1406
return self._make_parents_provider().get_parent_map(revision_ids)
887
# Hack to build up the caching logic.
888
ancestry = self._parents_map
890
# Repository is not locked, so there's no cache.
891
missing_revisions = set(keys)
894
missing_revisions = set(key for key in keys if key not in ancestry)
895
if missing_revisions:
896
parent_map = self._get_parent_map(missing_revisions)
897
if 'hpss' in debug.debug_flags:
898
mutter('retransmitted revisions: %d of %d',
899
len(set(ancestry).intersection(parent_map)),
901
ancestry.update(parent_map)
902
present_keys = [k for k in keys if k in ancestry]
903
if 'hpss' in debug.debug_flags:
904
if self._requested_parents is not None and len(ancestry) != 0:
905
self._requested_parents.update(present_keys)
906
mutter('Current RemoteRepository graph hit rate: %d%%',
907
100.0 * len(self._requested_parents) / len(ancestry))
908
return dict((k, ancestry[k]) for k in present_keys)
1408
def _get_parent_map_rpc(self, keys):
910
def _get_parent_map(self, keys):
1409
911
"""Helper for get_parent_map that performs the RPC."""
1410
912
medium = self._client._medium
1411
913
if medium._is_remote_before((1, 2)):
1412
914
# We already found out that the server can't understand
1413
915
# Repository.get_parent_map requests, so just fetch the whole
1416
# Note that this reads the whole graph, when only some keys are
1417
# wanted. On this old server there's no way (?) to get them all
1418
# in one go, and the user probably will have seen a warning about
1419
# the server being old anyhow.
1420
rg = self._get_revision_graph(None)
1421
# There is an API discrepancy between get_parent_map and
917
# XXX: Note that this will issue a deprecation warning. This is ok
918
# :- its because we're working with a deprecated server anyway, and
919
# the user will almost certainly have seen a warning about the
920
# server version already.
921
rg = self.get_revision_graph()
922
# There is an api discrepency between get_parent_map and
1422
923
# get_revision_graph. Specifically, a "key:()" pair in
1423
924
# get_revision_graph just means a node has no parents. For
1424
925
# "get_parent_map" it means the node is a ghost. So fix up the
1771
1229
self._ensure_real()
1772
1230
self._real_repository._pack_collection.autopack()
1232
if self._real_repository is not None:
1233
# Reset the real repository's cache of pack names.
1234
# XXX: At some point we may be able to skip this and just rely on
1235
# the automatic retry logic to do the right thing, but for now we
1236
# err on the side of being correct rather than being optimal.
1237
self._real_repository._pack_collection.reload_pack_names()
1775
1238
if response[0] != 'ok':
1776
1239
raise errors.UnexpectedSmartServerResponse(response)
1779
class RemoteStreamSink(repository.StreamSink):
1781
def _insert_real(self, stream, src_format, resume_tokens):
1782
self.target_repo._ensure_real()
1783
sink = self.target_repo._real_repository._get_sink()
1784
result = sink.insert_stream(stream, src_format, resume_tokens)
1786
self.target_repo.autopack()
1789
def insert_stream(self, stream, src_format, resume_tokens):
1790
target = self.target_repo
1791
target._unstacked_provider.missing_keys.clear()
1792
candidate_calls = [('Repository.insert_stream_1.19', (1, 19))]
1793
if target._lock_token:
1794
candidate_calls.append(('Repository.insert_stream_locked', (1, 14)))
1795
lock_args = (target._lock_token or '',)
1797
candidate_calls.append(('Repository.insert_stream', (1, 13)))
1799
client = target._client
1800
medium = client._medium
1801
path = target.bzrdir._path_for_remote_call(client)
1802
# Probe for the verb to use with an empty stream before sending the
1803
# real stream to it. We do this both to avoid the risk of sending a
1804
# large request that is then rejected, and because we don't want to
1805
# implement a way to buffer, rewind, or restart the stream.
1807
for verb, required_version in candidate_calls:
1808
if medium._is_remote_before(required_version):
1811
# We've already done the probing (and set _is_remote_before) on
1812
# a previous insert.
1815
byte_stream = smart_repo._stream_to_byte_stream([], src_format)
1817
response = client.call_with_body_stream(
1818
(verb, path, '') + lock_args, byte_stream)
1819
except errors.UnknownSmartMethod:
1820
medium._remember_remote_is_before(required_version)
1826
return self._insert_real(stream, src_format, resume_tokens)
1827
self._last_inv_record = None
1828
self._last_substream = None
1829
if required_version < (1, 19):
1830
# Remote side doesn't support inventory deltas. Wrap the stream to
1831
# make sure we don't send any. If the stream contains inventory
1832
# deltas we'll interrupt the smart insert_stream request and
1834
stream = self._stop_stream_if_inventory_delta(stream)
1835
byte_stream = smart_repo._stream_to_byte_stream(
1837
resume_tokens = ' '.join(resume_tokens)
1838
response = client.call_with_body_stream(
1839
(verb, path, resume_tokens) + lock_args, byte_stream)
1840
if response[0][0] not in ('ok', 'missing-basis'):
1841
raise errors.UnexpectedSmartServerResponse(response)
1842
if self._last_substream is not None:
1843
# The stream included an inventory-delta record, but the remote
1844
# side isn't new enough to support them. So we need to send the
1845
# rest of the stream via VFS.
1846
self.target_repo.refresh_data()
1847
return self._resume_stream_with_vfs(response, src_format)
1848
if response[0][0] == 'missing-basis':
1849
tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1850
resume_tokens = tokens
1851
return resume_tokens, set(missing_keys)
1853
self.target_repo.refresh_data()
1856
def _resume_stream_with_vfs(self, response, src_format):
1857
"""Resume sending a stream via VFS, first resending the record and
1858
substream that couldn't be sent via an insert_stream verb.
1860
if response[0][0] == 'missing-basis':
1861
tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1862
# Ignore missing_keys, we haven't finished inserting yet
1865
def resume_substream():
1866
# Yield the substream that was interrupted.
1867
for record in self._last_substream:
1869
self._last_substream = None
1870
def resume_stream():
1871
# Finish sending the interrupted substream
1872
yield ('inventory-deltas', resume_substream())
1873
# Then simply continue sending the rest of the stream.
1874
for substream_kind, substream in self._last_stream:
1875
yield substream_kind, substream
1876
return self._insert_real(resume_stream(), src_format, tokens)
1878
def _stop_stream_if_inventory_delta(self, stream):
1879
"""Normally this just lets the original stream pass-through unchanged.
1881
However if any 'inventory-deltas' substream occurs it will stop
1882
streaming, and store the interrupted substream and stream in
1883
self._last_substream and self._last_stream so that the stream can be
1884
resumed by _resume_stream_with_vfs.
1887
stream_iter = iter(stream)
1888
for substream_kind, substream in stream_iter:
1889
if substream_kind == 'inventory-deltas':
1890
self._last_substream = substream
1891
self._last_stream = stream_iter
1894
yield substream_kind, substream
1897
class RemoteStreamSource(repository.StreamSource):
1898
"""Stream data from a remote server."""
1900
def get_stream(self, search):
1901
if (self.from_repository._fallback_repositories and
1902
self.to_format._fetch_order == 'topological'):
1903
return self._real_stream(self.from_repository, search)
1906
repos = [self.from_repository]
1912
repos.extend(repo._fallback_repositories)
1913
sources.append(repo)
1914
return self.missing_parents_chain(search, sources)
1916
def get_stream_for_missing_keys(self, missing_keys):
1917
self.from_repository._ensure_real()
1918
real_repo = self.from_repository._real_repository
1919
real_source = real_repo._get_source(self.to_format)
1920
return real_source.get_stream_for_missing_keys(missing_keys)
1922
def _real_stream(self, repo, search):
1923
"""Get a stream for search from repo.
1925
This never called RemoteStreamSource.get_stream, and is a heler
1926
for RemoteStreamSource._get_stream to allow getting a stream
1927
reliably whether fallback back because of old servers or trying
1928
to stream from a non-RemoteRepository (which the stacked support
1931
source = repo._get_source(self.to_format)
1932
if isinstance(source, RemoteStreamSource):
1934
source = repo._real_repository._get_source(self.to_format)
1935
return source.get_stream(search)
1937
def _get_stream(self, repo, search):
1938
"""Core worker to get a stream from repo for search.
1940
This is used by both get_stream and the stacking support logic. It
1941
deliberately gets a stream for repo which does not need to be
1942
self.from_repository. In the event that repo is not Remote, or
1943
cannot do a smart stream, a fallback is made to the generic
1944
repository._get_stream() interface, via self._real_stream.
1946
In the event of stacking, streams from _get_stream will not
1947
contain all the data for search - this is normal (see get_stream).
1949
:param repo: A repository.
1950
:param search: A search.
1952
# Fallbacks may be non-smart
1953
if not isinstance(repo, RemoteRepository):
1954
return self._real_stream(repo, search)
1955
client = repo._client
1956
medium = client._medium
1957
path = repo.bzrdir._path_for_remote_call(client)
1958
search_bytes = repo._serialise_search_result(search)
1959
args = (path, self.to_format.network_name())
1961
('Repository.get_stream_1.19', (1, 19)),
1962
('Repository.get_stream', (1, 13))]
1964
for verb, version in candidate_verbs:
1965
if medium._is_remote_before(version):
1968
response = repo._call_with_body_bytes_expecting_body(
1969
verb, args, search_bytes)
1970
except errors.UnknownSmartMethod:
1971
medium._remember_remote_is_before(version)
1973
response_tuple, response_handler = response
1977
return self._real_stream(repo, search)
1978
if response_tuple[0] != 'ok':
1979
raise errors.UnexpectedSmartServerResponse(response_tuple)
1980
byte_stream = response_handler.read_streamed_body()
1981
src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
1982
if src_format.network_name() != repo._format.network_name():
1983
raise AssertionError(
1984
"Mismatched RemoteRepository and stream src %r, %r" % (
1985
src_format.network_name(), repo._format.network_name()))
1988
def missing_parents_chain(self, search, sources):
1989
"""Chain multiple streams together to handle stacking.
1991
:param search: The overall search to satisfy with streams.
1992
:param sources: A list of Repository objects to query.
1994
self.from_serialiser = self.from_repository._format._serializer
1995
self.seen_revs = set()
1996
self.referenced_revs = set()
1997
# If there are heads in the search, or the key count is > 0, we are not
1999
while not search.is_empty() and len(sources) > 1:
2000
source = sources.pop(0)
2001
stream = self._get_stream(source, search)
2002
for kind, substream in stream:
2003
if kind != 'revisions':
2004
yield kind, substream
2006
yield kind, self.missing_parents_rev_handler(substream)
2007
search = search.refine(self.seen_revs, self.referenced_revs)
2008
self.seen_revs = set()
2009
self.referenced_revs = set()
2010
if not search.is_empty():
2011
for kind, stream in self._get_stream(sources[0], search):
2014
def missing_parents_rev_handler(self, substream):
2015
for content in substream:
2016
revision_bytes = content.get_bytes_as('fulltext')
2017
revision = self.from_serialiser.read_revision_from_string(
2019
self.seen_revs.add(content.key[-1])
2020
self.referenced_revs.update(revision.parent_ids)
2024
1242
class RemoteBranchLockableFiles(LockableFiles):
2025
1243
"""A 'LockableFiles' implementation that talks to a smart server.
2027
1245
This is not a public interface class.
2044
1262
class RemoteBranchFormat(branch.BranchFormat):
2046
def __init__(self, network_name=None):
2047
super(RemoteBranchFormat, self).__init__()
2048
self._matchingbzrdir = RemoteBzrDirFormat()
2049
self._matchingbzrdir.set_branch_format(self)
2050
self._custom_format = None
2051
self._network_name = network_name
2053
1264
def __eq__(self, other):
2054
return (isinstance(other, RemoteBranchFormat) and
1265
return (isinstance(other, RemoteBranchFormat) and
2055
1266
self.__dict__ == other.__dict__)
2057
def _ensure_real(self):
2058
if self._custom_format is None:
2059
self._custom_format = branch.network_format_registry.get(
2062
1268
def get_format_description(self):
2064
return 'Remote: ' + self._custom_format.get_format_description()
2066
def network_name(self):
2067
return self._network_name
2069
def open(self, a_bzrdir, name=None, ignore_fallbacks=False):
2070
return a_bzrdir.open_branch(name=name,
2071
ignore_fallbacks=ignore_fallbacks)
2073
def _vfs_initialize(self, a_bzrdir, name):
2074
# Initialisation when using a local bzrdir object, or a non-vfs init
2075
# method is not available on the server.
2076
# self._custom_format is always set - the start of initialize ensures
2078
if isinstance(a_bzrdir, RemoteBzrDir):
2079
a_bzrdir._ensure_real()
2080
result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2083
# We assume the bzrdir is parameterised; it may not be.
2084
result = self._custom_format.initialize(a_bzrdir, name)
2085
if (isinstance(a_bzrdir, RemoteBzrDir) and
2086
not isinstance(result, RemoteBranch)):
2087
result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2091
def initialize(self, a_bzrdir, name=None):
2092
# 1) get the network name to use.
2093
if self._custom_format:
2094
network_name = self._custom_format.network_name()
2096
# Select the current bzrlib default and ask for that.
2097
reference_bzrdir_format = bzrdir.format_registry.get('default')()
2098
reference_format = reference_bzrdir_format.get_branch_format()
2099
self._custom_format = reference_format
2100
network_name = reference_format.network_name()
2101
# Being asked to create on a non RemoteBzrDir:
2102
if not isinstance(a_bzrdir, RemoteBzrDir):
2103
return self._vfs_initialize(a_bzrdir, name=name)
2104
medium = a_bzrdir._client._medium
2105
if medium._is_remote_before((1, 13)):
2106
return self._vfs_initialize(a_bzrdir, name=name)
2107
# Creating on a remote bzr dir.
2108
# 2) try direct creation via RPC
2109
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2110
if name is not None:
2111
# XXX JRV20100304: Support creating colocated branches
2112
raise errors.NoColocatedBranchSupport(self)
2113
verb = 'BzrDir.create_branch'
2115
response = a_bzrdir._call(verb, path, network_name)
2116
except errors.UnknownSmartMethod:
2117
# Fallback - use vfs methods
2118
medium._remember_remote_is_before((1, 13))
2119
return self._vfs_initialize(a_bzrdir, name=name)
2120
if response[0] != 'ok':
2121
raise errors.UnexpectedSmartServerResponse(response)
2122
# Turn the response into a RemoteRepository object.
2123
format = RemoteBranchFormat(network_name=response[1])
2124
repo_format = response_tuple_to_repo_format(response[3:])
2125
if response[2] == '':
2126
repo_bzrdir = a_bzrdir
2128
repo_bzrdir = RemoteBzrDir(
2129
a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
2131
remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2132
remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2133
format=format, setup_stacking=False, name=name)
2134
# XXX: We know this is a new branch, so it must have revno 0, revid
2135
# NULL_REVISION. Creating the branch locked would make this be unable
2136
# to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2137
remote_branch._last_revision_info_cache = 0, NULL_REVISION
2138
return remote_branch
2140
def make_tags(self, branch):
2142
return self._custom_format.make_tags(branch)
1269
return 'Remote BZR Branch'
1271
def get_format_string(self):
1272
return 'Remote BZR Branch'
1274
def open(self, a_bzrdir):
1275
return a_bzrdir.open_branch()
1277
def initialize(self, a_bzrdir):
1278
return a_bzrdir.create_branch()
2144
1280
def supports_tags(self):
2145
1281
# Remote branches might support tags, but we won't know until we
2146
1282
# access the real remote branch.
2148
return self._custom_format.supports_tags()
2150
def supports_stacking(self):
2152
return self._custom_format.supports_stacking()
2154
def supports_set_append_revisions_only(self):
2156
return self._custom_format.supports_set_append_revisions_only()
2159
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
1286
class RemoteBranch(branch.Branch, _RpcHelper):
2160
1287
"""Branch stored on a server accessed by HPSS RPC.
2162
1289
At the moment most operations are mapped down to simple file operations.
2165
1292
def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2166
_client=None, format=None, setup_stacking=True, name=None):
2167
1294
"""Create a RemoteBranch instance.
2169
1296
:param real_branch: An optional local implementation of the branch
2170
1297
format, usually accessing the data via the VFS.
2171
1298
:param _client: Private parameter for testing.
2172
:param format: A RemoteBranchFormat object, None to create one
2173
automatically. If supplied it should have a network_name already
2175
:param setup_stacking: If True make an RPC call to determine the
2176
stacked (or not) status of the branch. If False assume the branch
2178
:param name: Colocated branch name
2180
1300
# We intentionally don't call the parent class's __init__, because it
2181
1301
# will try to assign to self.tags, which is a property in this subclass.
2182
1302
# And the parent's __init__ doesn't do much anyway.
1303
self._revision_id_to_revno_cache = None
1304
self._revision_history_cache = None
1305
self._last_revision_info_cache = None
2183
1306
self.bzrdir = remote_bzrdir
2184
1307
if _client is not None:
2185
1308
self._client = _client
2353
1455
raise errors.UnexpectedSmartServerResponse(response)
2354
1456
return response[1]
2356
def set_stacked_on_url(self, url):
2357
branch.Branch.set_stacked_on_url(self, url)
2359
self._is_stacked = False
2361
self._is_stacked = True
2363
def _vfs_get_tags_bytes(self):
2365
return self._real_branch._get_tags_bytes()
2367
def _get_tags_bytes(self):
2368
medium = self._client._medium
2369
if medium._is_remote_before((1, 13)):
2370
return self._vfs_get_tags_bytes()
2372
response = self._call('Branch.get_tags_bytes', self._remote_path())
2373
except errors.UnknownSmartMethod:
2374
medium._remember_remote_is_before((1, 13))
2375
return self._vfs_get_tags_bytes()
2378
def _vfs_set_tags_bytes(self, bytes):
2380
return self._real_branch._set_tags_bytes(bytes)
2382
def _set_tags_bytes(self, bytes):
2383
medium = self._client._medium
2384
if medium._is_remote_before((1, 18)):
2385
self._vfs_set_tags_bytes(bytes)
2389
self._remote_path(), self._lock_token, self._repo_lock_token)
2390
response = self._call_with_body_bytes(
2391
'Branch.set_tags_bytes', args, bytes)
2392
except errors.UnknownSmartMethod:
2393
medium._remember_remote_is_before((1, 18))
2394
self._vfs_set_tags_bytes(bytes)
2396
1458
def lock_read(self):
2397
"""Lock the branch for read operations.
2399
:return: An object with an unlock method which will release the lock
2402
1459
self.repository.lock_read()
2403
1460
if not self._lock_mode:
2404
self._note_lock('r')
2405
1461
self._lock_mode = 'r'
2406
1462
self._lock_count = 1
2407
1463
if self._real_branch is not None:
2408
1464
self._real_branch.lock_read()
2410
1466
self._lock_count += 1
2413
1468
def _remote_lock_write(self, token):
2414
1469
if token is None:
2415
1470
branch_token = repo_token = ''
2417
1472
branch_token = token
2418
repo_token = self.repository.lock_write().repository_token
1473
repo_token = self.repository.lock_write()
2419
1474
self.repository.unlock()
2420
1475
err_context = {'token': token}
2421
1476
response = self._call(
2613
1625
rev_id = rev_history[-1]
2614
1626
self._set_last_revision(rev_id)
2615
for hook in branch.Branch.hooks['set_rh']:
2616
hook(self, rev_history)
2617
1627
self._cache_revision_history(rev_history)
2619
def _get_parent_location(self):
2620
medium = self._client._medium
2621
if medium._is_remote_before((1, 13)):
2622
return self._vfs_get_parent_location()
2624
response = self._call('Branch.get_parent', self._remote_path())
2625
except errors.UnknownSmartMethod:
2626
medium._remember_remote_is_before((1, 13))
2627
return self._vfs_get_parent_location()
2628
if len(response) != 1:
2629
raise errors.UnexpectedSmartServerResponse(response)
2630
parent_location = response[0]
2631
if parent_location == '':
2633
return parent_location
2635
def _vfs_get_parent_location(self):
2637
return self._real_branch._get_parent_location()
2639
def _set_parent_location(self, url):
2640
medium = self._client._medium
2641
if medium._is_remote_before((1, 15)):
2642
return self._vfs_set_parent_location(url)
2644
call_url = url or ''
2645
if type(call_url) is not str:
2646
raise AssertionError('url must be a str or None (%s)' % url)
2647
response = self._call('Branch.set_parent_location',
2648
self._remote_path(), self._lock_token, self._repo_lock_token,
2650
except errors.UnknownSmartMethod:
2651
medium._remember_remote_is_before((1, 15))
2652
return self._vfs_set_parent_location(url)
2654
raise errors.UnexpectedSmartServerResponse(response)
2656
def _vfs_set_parent_location(self, url):
2658
return self._real_branch._set_parent_location(url)
1629
def get_parent(self):
1631
return self._real_branch.get_parent()
1633
def set_parent(self, url):
1635
return self._real_branch.set_parent(url)
1637
def set_stacked_on_url(self, stacked_location):
1638
"""Set the URL this branch is stacked against.
1640
:raises UnstackableBranchFormat: If the branch does not support
1642
:raises UnstackableRepositoryFormat: If the repository does not support
1646
return self._real_branch.set_stacked_on_url(stacked_location)
1648
def sprout(self, to_bzrdir, revision_id=None):
1649
branch_format = to_bzrdir._format._branch_format
1650
if (branch_format is None or
1651
isinstance(branch_format, RemoteBranchFormat)):
1652
# The to_bzrdir specifies RemoteBranchFormat (or no format, which
1653
# implies the same thing), but RemoteBranches can't be created at
1654
# arbitrary URLs. So create a branch in the same format as
1655
# _real_branch instead.
1656
# XXX: if to_bzrdir is a RemoteBzrDir, this should perhaps do
1657
# to_bzrdir.create_branch to create a RemoteBranch after all...
1659
result = self._real_branch._format.initialize(to_bzrdir)
1660
self.copy_content_into(result, revision_id=revision_id)
1661
result.set_parent(self.bzrdir.root_transport.base)
1663
result = branch.Branch.sprout(
1664
self, to_bzrdir, revision_id=revision_id)
2660
1667
@needs_write_lock
2661
1668
def pull(self, source, overwrite=False, stop_revision=None,
2721
1723
except errors.UnknownSmartMethod:
2722
1724
medium._remember_remote_is_before((1, 6))
2723
1725
self._clear_cached_state_of_remote_branch_only()
2724
self.set_revision_history(self._lefthand_history(revision_id,
2725
last_rev=last_rev,other_branch=other_branch))
1727
self._real_branch.generate_revision_history(
1728
revision_id, last_rev=last_rev, other_branch=other_branch)
1733
return self._real_branch.tags
2727
1735
def set_push_location(self, location):
2728
1736
self._ensure_real()
2729
1737
return self._real_branch.set_push_location(location)
2732
class RemoteConfig(object):
2733
"""A Config that reads and writes from smart verbs.
2735
It is a low-level object that considers config data to be name/value pairs
2736
that may be associated with a section. Assigning meaning to the these
2737
values is done at higher levels like bzrlib.config.TreeConfig.
2740
def get_option(self, name, section=None, default=None):
2741
"""Return the value associated with a named option.
2743
:param name: The name of the value
2744
:param section: The section the option is in (if any)
2745
:param default: The value to return if the value is not set
2746
:return: The value or default value
1740
def update_revisions(self, other, stop_revision=None, overwrite=False,
1742
"""See Branch.update_revisions."""
2749
configobj = self._get_configobj()
2751
section_obj = configobj
1745
if stop_revision is None:
1746
stop_revision = other.last_revision()
1747
if revision.is_null(stop_revision):
1748
# if there are no commits, we're done.
1750
self.fetch(other, stop_revision)
1753
# Just unconditionally set the new revision. We don't care if
1754
# the branches have diverged.
1755
self._set_last_revision(stop_revision)
2754
section_obj = configobj[section]
2757
return section_obj.get(name, default)
2758
except errors.UnknownSmartMethod:
2759
return self._vfs_get_option(name, section, default)
2761
def _response_to_configobj(self, response):
2762
if len(response[0]) and response[0][0] != 'ok':
2763
raise errors.UnexpectedSmartServerResponse(response)
2764
lines = response[1].read_body_bytes().splitlines()
2765
return config.ConfigObj(lines, encoding='utf-8')
2768
class RemoteBranchConfig(RemoteConfig):
2769
"""A RemoteConfig for Branches."""
2771
def __init__(self, branch):
2772
self._branch = branch
2774
def _get_configobj(self):
2775
path = self._branch._remote_path()
2776
response = self._branch._client.call_expecting_body(
2777
'Branch.get_config_file', path)
2778
return self._response_to_configobj(response)
2780
def set_option(self, value, name, section=None):
2781
"""Set the value associated with a named option.
2783
:param value: The value to set
2784
:param name: The name of the value to set
2785
:param section: The section the option is in (if any)
2787
medium = self._branch._client._medium
2788
if medium._is_remote_before((1, 14)):
2789
return self._vfs_set_option(value, name, section)
2791
path = self._branch._remote_path()
2792
response = self._branch._client.call('Branch.set_config_option',
2793
path, self._branch._lock_token, self._branch._repo_lock_token,
2794
value.encode('utf8'), name, section or '')
2795
except errors.UnknownSmartMethod:
2796
medium._remember_remote_is_before((1, 14))
2797
return self._vfs_set_option(value, name, section)
2799
raise errors.UnexpectedSmartServerResponse(response)
2801
def _real_object(self):
2802
self._branch._ensure_real()
2803
return self._branch._real_branch
2805
def _vfs_set_option(self, value, name, section=None):
2806
return self._real_object()._get_config().set_option(
2807
value, name, section)
2810
class RemoteBzrDirConfig(RemoteConfig):
2811
"""A RemoteConfig for BzrDirs."""
2813
def __init__(self, bzrdir):
2814
self._bzrdir = bzrdir
2816
def _get_configobj(self):
2817
medium = self._bzrdir._client._medium
2818
verb = 'BzrDir.get_config_file'
2819
if medium._is_remote_before((1, 15)):
2820
raise errors.UnknownSmartMethod(verb)
2821
path = self._bzrdir._path_for_remote_call(self._bzrdir._client)
2822
response = self._bzrdir._call_expecting_body(
2824
return self._response_to_configobj(response)
2826
def _vfs_get_option(self, name, section, default):
2827
return self._real_object()._get_config().get_option(
2828
name, section, default)
2830
def set_option(self, value, name, section=None):
2831
"""Set the value associated with a named option.
2833
:param value: The value to set
2834
:param name: The name of the value to set
2835
:param section: The section the option is in (if any)
2837
return self._real_object()._get_config().set_option(
2838
value, name, section)
2840
def _real_object(self):
2841
self._bzrdir._ensure_real()
2842
return self._bzrdir._real_bzrdir
1757
medium = self._client._medium
1758
if not medium._is_remote_before((1, 6)):
1760
self._set_last_revision_descendant(stop_revision, other)
1762
except errors.UnknownSmartMethod:
1763
medium._remember_remote_is_before((1, 6))
1764
# Fallback for pre-1.6 servers: check for divergence
1765
# client-side, then do _set_last_revision.
1766
last_rev = revision.ensure_null(self.last_revision())
1768
graph = self.repository.get_graph()
1769
if self._check_if_descendant_or_diverged(
1770
stop_revision, last_rev, graph, other):
1771
# stop_revision is a descendant of last_rev, but we aren't
1772
# overwriting, so we're done.
1774
self._set_last_revision(stop_revision)
2846
1779
def _extract_tar(tar, to_dir):
added
removed
bzrlib/remote.py
