13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
# TODO: At some point, handle upgrades by just passing the whole request
18
# across to run on the server.
19
22
from bzrlib import (
30
repository as _mod_repository,
32
revision as _mod_revision,
36
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
33
from bzrlib.branch import BranchReferenceFormat
37
34
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
38
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
35
from bzrlib.decorators import needs_read_lock, needs_write_lock
39
36
from bzrlib.errors import (
41
38
SmartProtocolError,
43
40
from bzrlib.lockable_files import LockableFiles
44
from bzrlib.smart import client, vfs, repository as smart_repo
41
from bzrlib.smart import client, vfs
45
42
from bzrlib.revision import ensure_null, NULL_REVISION
46
from bzrlib.repository import RepositoryWriteLockResult
47
43
from bzrlib.trace import mutter, note, warning
50
class _RpcHelper(object):
51
"""Mixin class that helps with issuing RPCs."""
53
def _call(self, method, *args, **err_context):
55
return self._client.call(method, *args)
56
except errors.ErrorFromSmartServer, err:
57
self._translate_error(err, **err_context)
59
def _call_expecting_body(self, method, *args, **err_context):
61
return self._client.call_expecting_body(method, *args)
62
except errors.ErrorFromSmartServer, err:
63
self._translate_error(err, **err_context)
65
def _call_with_body_bytes(self, method, args, body_bytes, **err_context):
67
return self._client.call_with_body_bytes(method, args, body_bytes)
68
except errors.ErrorFromSmartServer, err:
69
self._translate_error(err, **err_context)
71
def _call_with_body_bytes_expecting_body(self, method, args, body_bytes,
74
return self._client.call_with_body_bytes_expecting_body(
75
method, args, body_bytes)
76
except errors.ErrorFromSmartServer, err:
77
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
46
# Note: RemoteBzrDirFormat is in bzrdir.py
92
class RemoteBzrDir(BzrDir, _RpcHelper):
48
class RemoteBzrDir(BzrDir):
93
49
"""Control directory on a remote server, accessed via bzr:// or similar."""
95
def __init__(self, transport, format, _client=None, _force_probe=False):
51
def __init__(self, transport, _client=None):
96
52
"""Construct a RemoteBzrDir.
98
54
:param _client: Private parameter for testing. Disables probing and the
99
55
use of a real bzrdir.
101
BzrDir.__init__(self, transport, format)
57
BzrDir.__init__(self, transport, RemoteBzrDirFormat())
102
58
# this object holds a delegated bzrdir that uses file-level operations
103
59
# to talk to the other side
104
60
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
62
if _client is None:
111
63
medium = transport.get_smart_medium()
112
64
self._client = client._SmartClient(medium)
114
66
self._client = _client
121
return '%s(%r)' % (self.__class__.__name__, self._client)
123
def _probe_bzrdir(self):
124
medium = self._client._medium
125
69
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
response = self._call('BzrDir.open', path)
70
response = self._client.call('BzrDir.open', path)
152
71
if response not in [('yes',), ('no',)]:
153
72
raise errors.UnexpectedSmartServerResponse(response)
154
73
if response == ('no',):
155
raise errors.NotBranchError(path=self.root_transport.base)
74
raise errors.NotBranchError(path=transport.base)
157
76
def _ensure_real(self):
158
77
"""Ensure that there is a _real_bzrdir set.
160
79
Used before calls to self._real_bzrdir.
162
81
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
82
self._real_bzrdir = BzrDir.open_from_transport(
168
83
self.root_transport, _server_formats=False)
169
self._format._network_name = \
170
self._real_bzrdir._format.network_name()
85
def cloning_metadir(self, stacked=False):
87
return self._real_bzrdir.cloning_metadir(stacked)
172
89
def _translate_error(self, err, **context):
173
90
_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):
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)
234
92
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()
94
self._real_bzrdir.create_repository(shared=shared)
95
return self.open_repository()
243
97
def destroy_repository(self):
244
98
"""See BzrDir.destroy_repository"""
245
99
self._ensure_real()
246
100
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
102
def create_branch(self):
104
real_branch = self._real_bzrdir.create_branch()
105
return RemoteBranch(self, self.find_repository(), real_branch)
267
def destroy_branch(self, name=None):
107
def destroy_branch(self):
268
108
"""See BzrDir.destroy_branch"""
269
109
self._ensure_real()
270
self._real_bzrdir.destroy_branch(name=name)
271
self._next_open_branch_result = None
110
self._real_bzrdir.destroy_branch()
273
112
def create_workingtree(self, revision_id=None, from_branch=None):
274
113
raise errors.NotLocalUrl(self.transport.base)
284
123
def get_branch_reference(self):
285
124
"""See BzrDir.get_branch_reference()."""
286
response = self._get_branch_reference()
287
if response[0] == 'ref':
125
path = self._path_for_remote_call(self._client)
127
response = self._client.call('BzrDir.open_branch', path)
128
except errors.ErrorFromSmartServer, err:
129
self._translate_error(err)
130
if response[0] == 'ok':
131
if response[1] == '':
132
# branch at this location.
135
# 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
138
raise errors.UnexpectedSmartServerResponse(response)
322
140
def _get_tree_branch(self):
323
141
"""See BzrDir._get_tree_branch()."""
324
142
return None, self.open_branch()
326
def open_branch(self, name=None, unsupported=False,
327
ignore_fallbacks=False):
144
def open_branch(self, _unsupported=False):
329
146
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':
147
reference_url = self.get_branch_reference()
148
if reference_url is None:
149
# branch at this location.
150
return RemoteBranch(self, self.find_repository())
337
152
# a branch reference, use the existing BranchReference logic.
338
153
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):
154
return format.open(self, _found=True, location=reference_url)
156
def open_repository(self):
157
path = self._path_for_remote_call(self._client)
361
158
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
response = self._call(verb, path)
377
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)
161
response = self._client.call(verb, path)
392
162
except errors.UnknownSmartMethod:
395
raise errors.UnknownSmartMethod('BzrDir.find_repository{3,2,}')
163
verb = 'BzrDir.find_repository'
164
response = self._client.call(verb, path)
165
except errors.ErrorFromSmartServer, err:
166
self._translate_error(err)
396
167
if response[0] != 'ok':
397
168
raise errors.UnexpectedSmartServerResponse(response)
398
if len(response) != 6:
169
if verb == 'BzrDir.find_repository':
170
# servers that don't support the V2 method don't support external
172
response = response + ('no', )
173
if not (len(response) == 5):
399
174
raise SmartProtocolError('incorrect response length %s' % (response,))
400
175
if response[1] == '':
401
# repo is at this dir.
402
format = response_tuple_to_repo_format(response[2:])
176
format = RemoteRepositoryFormat()
177
format.rich_root_data = (response[2] == 'yes')
178
format.supports_tree_reference = (response[3] == 'yes')
179
# No wire format to check this yet.
180
format.supports_external_lookups = (response[4] == 'yes')
403
181
# Used to support creating a real format instance when needed.
404
182
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)
183
return RemoteRepository(self, format)
411
185
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
187
def open_workingtree(self, recommend_upgrade=True):
420
if self.has_workingtree():
189
if self._real_bzrdir.has_workingtree():
421
190
raise errors.NotLocalUrl(self.root_transport)
423
192
raise errors.NoWorkingTree(self.root_transport.base)
470
237
the attributes rich_root_data and supports_tree_reference are set
471
238
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
242
_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
244
def initialize(self, a_bzrdir, shared=False):
245
if not isinstance(a_bzrdir, RemoteBzrDir):
541
246
prior_repo = self._creating_bzrdir.open_repository()
542
247
prior_repo._ensure_real()
543
result = prior_repo._real_repository._format.initialize(
248
return prior_repo._real_repository._format.initialize(
544
249
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
250
return a_bzrdir.create_repository(shared=shared)
598
252
def open(self, a_bzrdir):
599
253
if not isinstance(a_bzrdir, RemoteBzrDir):
600
254
raise AssertionError('%r is not a RemoteBzrDir' % (a_bzrdir,))
601
255
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
257
def get_format_description(self):
625
return 'Remote: ' + self._custom_format.get_format_description()
258
return 'bzr remote repository'
627
260
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):
261
return self.__class__ == other.__class__
263
def check_conversion_target(self, target_format):
264
if self.rich_root_data and not target_format.rich_root_data:
265
raise errors.BadConversionTarget(
266
'Does not support rich root data.', target_format)
267
if (self.supports_tree_reference and
268
not getattr(target_format, 'supports_tree_reference', False)):
269
raise errors.BadConversionTarget(
270
'Does not support nested trees', target_format)
273
class RemoteRepository(object):
649
274
"""Repository accessed over rpc.
651
276
For the moment most operations are performed using local transport-backed
745
345
self._ensure_real()
746
346
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
348
def _ensure_real(self):
793
349
"""Ensure that there is a _real_repository set.
795
351
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
353
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
354
self.bzrdir._ensure_real()
812
355
self._set_real_repository(
813
356
self.bzrdir._real_bzrdir.open_repository())
862
413
for line in lines:
863
414
d = tuple(line.split())
864
415
revision_graph[d[0]] = d[1:]
866
417
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
419
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,))
420
"""See Repository.has_revision()."""
421
if revision_id == NULL_REVISION:
422
# The null revision is always present.
424
path = self.bzrdir._path_for_remote_call(self._client)
425
response = self._client.call(
426
'Repository.has_revision', path, revision_id)
427
if response[0] not in ('yes', 'no'):
428
raise errors.UnexpectedSmartServerResponse(response)
429
if response[0] == 'yes':
431
for fallback_repo in self._fallback_repositories:
432
if fallback_repo.has_revision(revision_id):
883
436
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)
437
"""See Repository.has_revisions()."""
438
# FIXME: This does many roundtrips, particularly when there are
439
# fallback repositories. -- mbp 20080905
441
for revision_id in revision_ids:
442
if self.has_revision(revision_id):
443
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
446
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
447
return (self.__class__ == other.__class__ and
914
448
self.bzrdir.transport.base == other.bzrdir.transport.base)
916
450
def get_graph(self, other_repository=None):
917
451
"""Return the graph for this repository format"""
918
parents_provider = self._make_parents_provider(other_repository)
452
parents_provider = self
453
if (other_repository is not None and
454
other_repository.bzrdir.transport.base !=
455
self.bzrdir.transport.base):
456
parents_provider = graph._StackedParentsProvider(
457
[parents_provider, other_repository._make_parents_provider()])
919
458
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
460
def gather_stats(self, revid=None, committers=None):
931
461
"""See Repository.gather_stats()."""
932
462
path = self.bzrdir._path_for_remote_call(self._client)
1233
723
def add_fallback_repository(self, repository):
1234
724
"""Add a repository to use for looking up data not held locally.
1236
726
:param repository: A repository.
1238
if not self._format.supports_external_lookups:
1239
raise errors.UnstackableRepositoryFormat(
1240
self._format.network_name(), self.base)
728
# XXX: At the moment the RemoteRepository will allow fallbacks
729
# unconditionally - however, a _real_repository will usually exist,
730
# and may raise an error if it's not accommodated by the underlying
731
# format. Eventually we should check when opening the repository
732
# whether it's willing to allow them or not.
1241
734
# We need to accumulate additional repositories here, to pass them in
1242
735
# on various RPC's.
1244
if self.is_locked():
1245
# We will call fallback.unlock() when we transition to the unlocked
1246
# state, so always add a lock here. If a caller passes us a locked
1247
# repository, they are responsible for unlocking it later.
1248
repository.lock_read()
1249
self._check_fallback_repository(repository)
1250
736
self._fallback_repositories.append(repository)
1251
# If self._real_repository was parameterised already (e.g. because a
1252
# _real_branch had its get_stacked_on_url method called), then the
1253
# repository to be added may already be in the _real_repositories list.
1254
if self._real_repository is not None:
1255
fallback_locations = [repo.user_url for repo in
1256
self._real_repository._fallback_repositories]
1257
if repository.user_url not in fallback_locations:
1258
self._real_repository.add_fallback_repository(repository)
1260
def _check_fallback_repository(self, repository):
1261
"""Check that this repository can fallback to repository safely.
1263
Raise an error if not.
1265
:param repository: A repository to fallback to.
1267
return _mod_repository.InterRepository._assert_same_model(
737
# They are also seen by the fallback repository. If it doesn't exist
738
# yet they'll be added then. This implicitly copies them.
1270
741
def add_inventory(self, revid, inv, parents):
1271
742
self._ensure_real()
1272
743
return self._real_repository.add_inventory(revid, inv, parents)
1274
def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1275
parents, basis_inv=None, propagate_caches=False):
1277
return self._real_repository.add_inventory_by_delta(basis_revision_id,
1278
delta, new_revision_id, parents, basis_inv=basis_inv,
1279
propagate_caches=propagate_caches)
1281
745
def add_revision(self, rev_id, rev, inv=None, config=None):
1282
746
self._ensure_real()
1283
747
return self._real_repository.add_revision(
1393
831
self._ensure_real()
1394
832
return self._real_repository._get_versioned_file_checker(
1395
833
revisions, revision_versions_cache)
1397
835
def iter_files_bytes(self, desired_files):
1398
836
"""See Repository.iter_file_bytes.
1400
838
self._ensure_real()
1401
839
return self._real_repository.iter_files_bytes(desired_files)
1403
def get_parent_map(self, revision_ids):
842
def _fetch_order(self):
843
"""Decorate the real repository for now.
845
In the long term getting this back from the remote repository as part
846
of open would be more efficient.
849
return self._real_repository._fetch_order
852
def _fetch_uses_deltas(self):
853
"""Decorate the real repository for now.
855
In the long term getting this back from the remote repository as part
856
of open would be more efficient.
859
return self._real_repository._fetch_uses_deltas
862
def _fetch_reconcile(self):
863
"""Decorate the real repository for now.
865
In the long term getting this back from the remote repository as part
866
of open would be more efficient.
869
return self._real_repository._fetch_reconcile
871
def get_parent_map(self, keys):
1404
872
"""See bzrlib.Graph.get_parent_map()."""
1405
return self._make_parents_provider().get_parent_map(revision_ids)
873
# Hack to build up the caching logic.
874
ancestry = self._parents_map
876
# Repository is not locked, so there's no cache.
877
missing_revisions = set(keys)
880
missing_revisions = set(key for key in keys if key not in ancestry)
881
if missing_revisions:
882
parent_map = self._get_parent_map(missing_revisions)
883
if 'hpss' in debug.debug_flags:
884
mutter('retransmitted revisions: %d of %d',
885
len(set(ancestry).intersection(parent_map)),
887
ancestry.update(parent_map)
888
present_keys = [k for k in keys if k in ancestry]
889
if 'hpss' in debug.debug_flags:
890
if self._requested_parents is not None and len(ancestry) != 0:
891
self._requested_parents.update(present_keys)
892
mutter('Current RemoteRepository graph hit rate: %d%%',
893
100.0 * len(self._requested_parents) / len(ancestry))
894
return dict((k, ancestry[k]) for k in present_keys)
1407
def _get_parent_map_rpc(self, keys):
896
def _get_parent_map(self, keys):
1408
897
"""Helper for get_parent_map that performs the RPC."""
1409
898
medium = self._client._medium
1410
899
if medium._is_remote_before((1, 2)):
1411
900
# We already found out that the server can't understand
1412
901
# Repository.get_parent_map requests, so just fetch the whole
1415
# Note that this reads the whole graph, when only some keys are
1416
# wanted. On this old server there's no way (?) to get them all
1417
# in one go, and the user probably will have seen a warning about
1418
# the server being old anyhow.
1419
rg = self._get_revision_graph(None)
1420
# There is an API discrepancy between get_parent_map and
903
# XXX: Note that this will issue a deprecation warning. This is ok
904
# :- its because we're working with a deprecated server anyway, and
905
# the user will almost certainly have seen a warning about the
906
# server version already.
907
rg = self.get_revision_graph()
908
# There is an api discrepency between get_parent_map and
1421
909
# get_revision_graph. Specifically, a "key:()" pair in
1422
910
# get_revision_graph just means a node has no parents. For
1423
911
# "get_parent_map" it means the node is a ghost. So fix up the
1748
1202
:param recipe: A search recipe (start, stop, count).
1749
1203
:return: Serialised bytes.
1751
start_keys = ' '.join(recipe[1])
1752
stop_keys = ' '.join(recipe[2])
1753
count = str(recipe[3])
1205
start_keys = ' '.join(recipe[0])
1206
stop_keys = ' '.join(recipe[1])
1207
count = str(recipe[2])
1754
1208
return '\n'.join((start_keys, stop_keys, count))
1756
def _serialise_search_result(self, search_result):
1757
if isinstance(search_result, graph.PendingAncestryResult):
1758
parts = ['ancestry-of']
1759
parts.extend(search_result.heads)
1761
recipe = search_result.get_recipe()
1762
parts = [recipe[0], self._serialise_search_recipe(recipe)]
1763
return '\n'.join(parts)
1766
path = self.bzrdir._path_for_remote_call(self._client)
1768
response = self._call('PackRepository.autopack', path)
1769
except errors.UnknownSmartMethod:
1771
self._real_repository._pack_collection.autopack()
1774
if response[0] != 'ok':
1775
raise errors.UnexpectedSmartServerResponse(response)
1778
class RemoteStreamSink(repository.StreamSink):
1780
def _insert_real(self, stream, src_format, resume_tokens):
1781
self.target_repo._ensure_real()
1782
sink = self.target_repo._real_repository._get_sink()
1783
result = sink.insert_stream(stream, src_format, resume_tokens)
1785
self.target_repo.autopack()
1788
def insert_stream(self, stream, src_format, resume_tokens):
1789
target = self.target_repo
1790
target._unstacked_provider.missing_keys.clear()
1791
candidate_calls = [('Repository.insert_stream_1.19', (1, 19))]
1792
if target._lock_token:
1793
candidate_calls.append(('Repository.insert_stream_locked', (1, 14)))
1794
lock_args = (target._lock_token or '',)
1796
candidate_calls.append(('Repository.insert_stream', (1, 13)))
1798
client = target._client
1799
medium = client._medium
1800
path = target.bzrdir._path_for_remote_call(client)
1801
# Probe for the verb to use with an empty stream before sending the
1802
# real stream to it. We do this both to avoid the risk of sending a
1803
# large request that is then rejected, and because we don't want to
1804
# implement a way to buffer, rewind, or restart the stream.
1806
for verb, required_version in candidate_calls:
1807
if medium._is_remote_before(required_version):
1810
# We've already done the probing (and set _is_remote_before) on
1811
# a previous insert.
1814
byte_stream = smart_repo._stream_to_byte_stream([], src_format)
1816
response = client.call_with_body_stream(
1817
(verb, path, '') + lock_args, byte_stream)
1818
except errors.UnknownSmartMethod:
1819
medium._remember_remote_is_before(required_version)
1825
return self._insert_real(stream, src_format, resume_tokens)
1826
self._last_inv_record = None
1827
self._last_substream = None
1828
if required_version < (1, 19):
1829
# Remote side doesn't support inventory deltas. Wrap the stream to
1830
# make sure we don't send any. If the stream contains inventory
1831
# deltas we'll interrupt the smart insert_stream request and
1833
stream = self._stop_stream_if_inventory_delta(stream)
1834
byte_stream = smart_repo._stream_to_byte_stream(
1836
resume_tokens = ' '.join(resume_tokens)
1837
response = client.call_with_body_stream(
1838
(verb, path, resume_tokens) + lock_args, byte_stream)
1839
if response[0][0] not in ('ok', 'missing-basis'):
1840
raise errors.UnexpectedSmartServerResponse(response)
1841
if self._last_substream is not None:
1842
# The stream included an inventory-delta record, but the remote
1843
# side isn't new enough to support them. So we need to send the
1844
# rest of the stream via VFS.
1845
self.target_repo.refresh_data()
1846
return self._resume_stream_with_vfs(response, src_format)
1847
if response[0][0] == 'missing-basis':
1848
tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1849
resume_tokens = tokens
1850
return resume_tokens, set(missing_keys)
1852
self.target_repo.refresh_data()
1855
def _resume_stream_with_vfs(self, response, src_format):
1856
"""Resume sending a stream via VFS, first resending the record and
1857
substream that couldn't be sent via an insert_stream verb.
1859
if response[0][0] == 'missing-basis':
1860
tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1861
# Ignore missing_keys, we haven't finished inserting yet
1864
def resume_substream():
1865
# Yield the substream that was interrupted.
1866
for record in self._last_substream:
1868
self._last_substream = None
1869
def resume_stream():
1870
# Finish sending the interrupted substream
1871
yield ('inventory-deltas', resume_substream())
1872
# Then simply continue sending the rest of the stream.
1873
for substream_kind, substream in self._last_stream:
1874
yield substream_kind, substream
1875
return self._insert_real(resume_stream(), src_format, tokens)
1877
def _stop_stream_if_inventory_delta(self, stream):
1878
"""Normally this just lets the original stream pass-through unchanged.
1880
However if any 'inventory-deltas' substream occurs it will stop
1881
streaming, and store the interrupted substream and stream in
1882
self._last_substream and self._last_stream so that the stream can be
1883
resumed by _resume_stream_with_vfs.
1886
stream_iter = iter(stream)
1887
for substream_kind, substream in stream_iter:
1888
if substream_kind == 'inventory-deltas':
1889
self._last_substream = substream
1890
self._last_stream = stream_iter
1893
yield substream_kind, substream
1896
class RemoteStreamSource(repository.StreamSource):
1897
"""Stream data from a remote server."""
1899
def get_stream(self, search):
1900
if (self.from_repository._fallback_repositories and
1901
self.to_format._fetch_order == 'topological'):
1902
return self._real_stream(self.from_repository, search)
1905
repos = [self.from_repository]
1911
repos.extend(repo._fallback_repositories)
1912
sources.append(repo)
1913
return self.missing_parents_chain(search, sources)
1915
def get_stream_for_missing_keys(self, missing_keys):
1916
self.from_repository._ensure_real()
1917
real_repo = self.from_repository._real_repository
1918
real_source = real_repo._get_source(self.to_format)
1919
return real_source.get_stream_for_missing_keys(missing_keys)
1921
def _real_stream(self, repo, search):
1922
"""Get a stream for search from repo.
1924
This never called RemoteStreamSource.get_stream, and is a heler
1925
for RemoteStreamSource._get_stream to allow getting a stream
1926
reliably whether fallback back because of old servers or trying
1927
to stream from a non-RemoteRepository (which the stacked support
1930
source = repo._get_source(self.to_format)
1931
if isinstance(source, RemoteStreamSource):
1933
source = repo._real_repository._get_source(self.to_format)
1934
return source.get_stream(search)
1936
def _get_stream(self, repo, search):
1937
"""Core worker to get a stream from repo for search.
1939
This is used by both get_stream and the stacking support logic. It
1940
deliberately gets a stream for repo which does not need to be
1941
self.from_repository. In the event that repo is not Remote, or
1942
cannot do a smart stream, a fallback is made to the generic
1943
repository._get_stream() interface, via self._real_stream.
1945
In the event of stacking, streams from _get_stream will not
1946
contain all the data for search - this is normal (see get_stream).
1948
:param repo: A repository.
1949
:param search: A search.
1951
# Fallbacks may be non-smart
1952
if not isinstance(repo, RemoteRepository):
1953
return self._real_stream(repo, search)
1954
client = repo._client
1955
medium = client._medium
1956
path = repo.bzrdir._path_for_remote_call(client)
1957
search_bytes = repo._serialise_search_result(search)
1958
args = (path, self.to_format.network_name())
1960
('Repository.get_stream_1.19', (1, 19)),
1961
('Repository.get_stream', (1, 13))]
1963
for verb, version in candidate_verbs:
1964
if medium._is_remote_before(version):
1967
response = repo._call_with_body_bytes_expecting_body(
1968
verb, args, search_bytes)
1969
except errors.UnknownSmartMethod:
1970
medium._remember_remote_is_before(version)
1972
response_tuple, response_handler = response
1976
return self._real_stream(repo, search)
1977
if response_tuple[0] != 'ok':
1978
raise errors.UnexpectedSmartServerResponse(response_tuple)
1979
byte_stream = response_handler.read_streamed_body()
1980
src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
1981
if src_format.network_name() != repo._format.network_name():
1982
raise AssertionError(
1983
"Mismatched RemoteRepository and stream src %r, %r" % (
1984
src_format.network_name(), repo._format.network_name()))
1987
def missing_parents_chain(self, search, sources):
1988
"""Chain multiple streams together to handle stacking.
1990
:param search: The overall search to satisfy with streams.
1991
:param sources: A list of Repository objects to query.
1993
self.from_serialiser = self.from_repository._format._serializer
1994
self.seen_revs = set()
1995
self.referenced_revs = set()
1996
# If there are heads in the search, or the key count is > 0, we are not
1998
while not search.is_empty() and len(sources) > 1:
1999
source = sources.pop(0)
2000
stream = self._get_stream(source, search)
2001
for kind, substream in stream:
2002
if kind != 'revisions':
2003
yield kind, substream
2005
yield kind, self.missing_parents_rev_handler(substream)
2006
search = search.refine(self.seen_revs, self.referenced_revs)
2007
self.seen_revs = set()
2008
self.referenced_revs = set()
2009
if not search.is_empty():
2010
for kind, stream in self._get_stream(sources[0], search):
2013
def missing_parents_rev_handler(self, substream):
2014
for content in substream:
2015
revision_bytes = content.get_bytes_as('fulltext')
2016
revision = self.from_serialiser.read_revision_from_string(
2018
self.seen_revs.add(content.key[-1])
2019
self.referenced_revs.update(revision.parent_ids)
2023
1211
class RemoteBranchLockableFiles(LockableFiles):
2024
1212
"""A 'LockableFiles' implementation that talks to a smart server.
2026
1214
This is not a public interface class.
2043
1231
class RemoteBranchFormat(branch.BranchFormat):
2045
def __init__(self, network_name=None):
2046
super(RemoteBranchFormat, self).__init__()
2047
self._matchingbzrdir = RemoteBzrDirFormat()
2048
self._matchingbzrdir.set_branch_format(self)
2049
self._custom_format = None
2050
self._network_name = network_name
2052
1233
def __eq__(self, other):
2053
return (isinstance(other, RemoteBranchFormat) and
1234
return (isinstance(other, RemoteBranchFormat) and
2054
1235
self.__dict__ == other.__dict__)
2056
def _ensure_real(self):
2057
if self._custom_format is None:
2058
self._custom_format = branch.network_format_registry.get(
2061
1237
def get_format_description(self):
2063
return 'Remote: ' + self._custom_format.get_format_description()
2065
def network_name(self):
2066
return self._network_name
2068
def open(self, a_bzrdir, name=None, ignore_fallbacks=False):
2069
return a_bzrdir.open_branch(name=name,
2070
ignore_fallbacks=ignore_fallbacks)
2072
def _vfs_initialize(self, a_bzrdir, name):
2073
# Initialisation when using a local bzrdir object, or a non-vfs init
2074
# method is not available on the server.
2075
# self._custom_format is always set - the start of initialize ensures
2077
if isinstance(a_bzrdir, RemoteBzrDir):
2078
a_bzrdir._ensure_real()
2079
result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2082
# We assume the bzrdir is parameterised; it may not be.
2083
result = self._custom_format.initialize(a_bzrdir, name)
2084
if (isinstance(a_bzrdir, RemoteBzrDir) and
2085
not isinstance(result, RemoteBranch)):
2086
result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2090
def initialize(self, a_bzrdir, name=None):
2091
# 1) get the network name to use.
2092
if self._custom_format:
2093
network_name = self._custom_format.network_name()
2095
# Select the current bzrlib default and ask for that.
2096
reference_bzrdir_format = bzrdir.format_registry.get('default')()
2097
reference_format = reference_bzrdir_format.get_branch_format()
2098
self._custom_format = reference_format
2099
network_name = reference_format.network_name()
2100
# Being asked to create on a non RemoteBzrDir:
2101
if not isinstance(a_bzrdir, RemoteBzrDir):
2102
return self._vfs_initialize(a_bzrdir, name=name)
2103
medium = a_bzrdir._client._medium
2104
if medium._is_remote_before((1, 13)):
2105
return self._vfs_initialize(a_bzrdir, name=name)
2106
# Creating on a remote bzr dir.
2107
# 2) try direct creation via RPC
2108
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2109
if name is not None:
2110
# XXX JRV20100304: Support creating colocated branches
2111
raise errors.NoColocatedBranchSupport(self)
2112
verb = 'BzrDir.create_branch'
2114
response = a_bzrdir._call(verb, path, network_name)
2115
except errors.UnknownSmartMethod:
2116
# Fallback - use vfs methods
2117
medium._remember_remote_is_before((1, 13))
2118
return self._vfs_initialize(a_bzrdir, name=name)
2119
if response[0] != 'ok':
2120
raise errors.UnexpectedSmartServerResponse(response)
2121
# Turn the response into a RemoteRepository object.
2122
format = RemoteBranchFormat(network_name=response[1])
2123
repo_format = response_tuple_to_repo_format(response[3:])
2124
if response[2] == '':
2125
repo_bzrdir = a_bzrdir
2127
repo_bzrdir = RemoteBzrDir(
2128
a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
2130
remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2131
remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2132
format=format, setup_stacking=False, name=name)
2133
# XXX: We know this is a new branch, so it must have revno 0, revid
2134
# NULL_REVISION. Creating the branch locked would make this be unable
2135
# to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2136
remote_branch._last_revision_info_cache = 0, NULL_REVISION
2137
return remote_branch
2139
def make_tags(self, branch):
2141
return self._custom_format.make_tags(branch)
1238
return 'Remote BZR Branch'
1240
def get_format_string(self):
1241
return 'Remote BZR Branch'
1243
def open(self, a_bzrdir):
1244
return a_bzrdir.open_branch()
1246
def initialize(self, a_bzrdir):
1247
return a_bzrdir.create_branch()
2143
1249
def supports_tags(self):
2144
1250
# Remote branches might support tags, but we won't know until we
2145
1251
# access the real remote branch.
2147
return self._custom_format.supports_tags()
2149
def supports_stacking(self):
2151
return self._custom_format.supports_stacking()
2153
def supports_set_append_revisions_only(self):
2155
return self._custom_format.supports_set_append_revisions_only()
2158
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
1255
class RemoteBranch(branch.Branch):
2159
1256
"""Branch stored on a server accessed by HPSS RPC.
2161
1258
At the moment most operations are mapped down to simple file operations.
2164
1261
def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2165
_client=None, format=None, setup_stacking=True, name=None):
2166
1263
"""Create a RemoteBranch instance.
2168
1265
:param real_branch: An optional local implementation of the branch
2169
1266
format, usually accessing the data via the VFS.
2170
1267
:param _client: Private parameter for testing.
2171
:param format: A RemoteBranchFormat object, None to create one
2172
automatically. If supplied it should have a network_name already
2174
:param setup_stacking: If True make an RPC call to determine the
2175
stacked (or not) status of the branch. If False assume the branch
2177
:param name: Colocated branch name
2179
1269
# We intentionally don't call the parent class's __init__, because it
2180
1270
# will try to assign to self.tags, which is a property in this subclass.
2181
1271
# And the parent's __init__ doesn't do much anyway.
1272
self._revision_id_to_revno_cache = None
1273
self._revision_history_cache = None
1274
self._last_revision_info_cache = None
2182
1275
self.bzrdir = remote_bzrdir
2183
1276
if _client is not None:
2184
1277
self._client = _client
2348
1421
except errors.UnknownSmartMethod, err:
2349
1422
self._ensure_real()
2350
1423
return self._real_branch.get_stacked_on_url()
2351
if response[0] != 'ok':
2352
raise errors.UnexpectedSmartServerResponse(response)
2355
def set_stacked_on_url(self, url):
2356
branch.Branch.set_stacked_on_url(self, url)
2358
self._is_stacked = False
2360
self._is_stacked = True
2362
def _vfs_get_tags_bytes(self):
2364
return self._real_branch._get_tags_bytes()
2366
def _get_tags_bytes(self):
2367
medium = self._client._medium
2368
if medium._is_remote_before((1, 13)):
2369
return self._vfs_get_tags_bytes()
2371
response = self._call('Branch.get_tags_bytes', self._remote_path())
2372
except errors.UnknownSmartMethod:
2373
medium._remember_remote_is_before((1, 13))
2374
return self._vfs_get_tags_bytes()
2377
def _vfs_set_tags_bytes(self, bytes):
2379
return self._real_branch._set_tags_bytes(bytes)
2381
def _set_tags_bytes(self, bytes):
2382
medium = self._client._medium
2383
if medium._is_remote_before((1, 18)):
2384
self._vfs_set_tags_bytes(bytes)
2388
self._remote_path(), self._lock_token, self._repo_lock_token)
2389
response = self._call_with_body_bytes(
2390
'Branch.set_tags_bytes', args, bytes)
2391
except errors.UnknownSmartMethod:
2392
medium._remember_remote_is_before((1, 18))
2393
self._vfs_set_tags_bytes(bytes)
2395
1425
def lock_read(self):
2396
"""Lock the branch for read operations.
2398
:return: A bzrlib.lock.LogicalLockResult.
2400
1426
self.repository.lock_read()
2401
1427
if not self._lock_mode:
2402
self._note_lock('r')
2403
1428
self._lock_mode = 'r'
2404
1429
self._lock_count = 1
2405
1430
if self._real_branch is not None:
2406
1431
self._real_branch.lock_read()
2408
1433
self._lock_count += 1
2409
return lock.LogicalLockResult(self.unlock)
2411
1435
def _remote_lock_write(self, token):
2412
1436
if token is None:
2413
1437
branch_token = repo_token = ''
2415
1439
branch_token = token
2416
repo_token = self.repository.lock_write().repository_token
1440
repo_token = self.repository.lock_write()
2417
1441
self.repository.unlock()
2418
err_context = {'token': token}
2419
response = self._call(
2420
'Branch.lock_write', self._remote_path(), branch_token,
2421
repo_token or '', **err_context)
1443
response = self._client.call(
1444
'Branch.lock_write', self._remote_path(),
1445
branch_token, repo_token or '')
1446
except errors.ErrorFromSmartServer, err:
1447
self._translate_error(err, token=token)
2422
1448
if response[0] != 'ok':
2423
1449
raise errors.UnexpectedSmartServerResponse(response)
2424
1450
ok, branch_token, repo_token = response
2425
1451
return branch_token, repo_token
2427
1453
def lock_write(self, token=None):
2428
1454
if not self._lock_mode:
2429
self._note_lock('w')
2430
1455
# Lock the branch and repo in one remote call.
2431
1456
remote_tokens = self._remote_lock_write(token)
2432
1457
self._lock_token, self._repo_lock_token = remote_tokens
2559
1563
def _set_last_revision_descendant(self, revision_id, other_branch,
2560
1564
allow_diverged=False, allow_overwrite_descendant=False):
2561
# This performs additional work to meet the hook contract; while its
2562
# undesirable, we have to synthesise the revno to call the hook, and
2563
# not calling the hook is worse as it means changes can't be prevented.
2564
# Having calculated this though, we can't just call into
2565
# set_last_revision_info as a simple call, because there is a set_rh
2566
# hook that some folk may still be using.
2567
old_revno, old_revid = self.last_revision_info()
2568
history = self._lefthand_history(revision_id)
2569
self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2570
err_context = {'other_branch': other_branch}
2571
response = self._call('Branch.set_last_revision_ex',
2572
self._remote_path(), self._lock_token, self._repo_lock_token,
2573
revision_id, int(allow_diverged), int(allow_overwrite_descendant),
1566
response = self._client.call('Branch.set_last_revision_ex',
1567
self._remote_path(), self._lock_token, self._repo_lock_token, revision_id,
1568
int(allow_diverged), int(allow_overwrite_descendant))
1569
except errors.ErrorFromSmartServer, err:
1570
self._translate_error(err, other_branch=other_branch)
2575
1571
self._clear_cached_state()
2576
1572
if len(response) != 3 and response[0] != 'ok':
2577
1573
raise errors.UnexpectedSmartServerResponse(response)
2578
1574
new_revno, new_revision_id = response[1:]
2579
1575
self._last_revision_info_cache = new_revno, new_revision_id
2580
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2581
1576
if self._real_branch is not None:
2582
1577
cache = new_revno, new_revision_id
2583
1578
self._real_branch._last_revision_info_cache = cache
2585
1580
def _set_last_revision(self, revision_id):
2586
old_revno, old_revid = self.last_revision_info()
2587
# This performs additional work to meet the hook contract; while its
2588
# undesirable, we have to synthesise the revno to call the hook, and
2589
# not calling the hook is worse as it means changes can't be prevented.
2590
# Having calculated this though, we can't just call into
2591
# set_last_revision_info as a simple call, because there is a set_rh
2592
# hook that some folk may still be using.
2593
history = self._lefthand_history(revision_id)
2594
self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2595
1581
self._clear_cached_state()
2596
response = self._call('Branch.set_last_revision',
2597
self._remote_path(), self._lock_token, self._repo_lock_token,
1583
response = self._client.call('Branch.set_last_revision',
1584
self._remote_path(), self._lock_token, self._repo_lock_token, revision_id)
1585
except errors.ErrorFromSmartServer, err:
1586
self._translate_error(err)
2599
1587
if response != ('ok',):
2600
1588
raise errors.UnexpectedSmartServerResponse(response)
2601
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2603
1590
@needs_write_lock
2604
1591
def set_revision_history(self, rev_history):
2611
1598
rev_id = rev_history[-1]
2612
1599
self._set_last_revision(rev_id)
2613
for hook in branch.Branch.hooks['set_rh']:
2614
hook(self, rev_history)
2615
1600
self._cache_revision_history(rev_history)
2617
def _get_parent_location(self):
2618
medium = self._client._medium
2619
if medium._is_remote_before((1, 13)):
2620
return self._vfs_get_parent_location()
2622
response = self._call('Branch.get_parent', self._remote_path())
2623
except errors.UnknownSmartMethod:
2624
medium._remember_remote_is_before((1, 13))
2625
return self._vfs_get_parent_location()
2626
if len(response) != 1:
2627
raise errors.UnexpectedSmartServerResponse(response)
2628
parent_location = response[0]
2629
if parent_location == '':
2631
return parent_location
2633
def _vfs_get_parent_location(self):
2635
return self._real_branch._get_parent_location()
2637
def _set_parent_location(self, url):
2638
medium = self._client._medium
2639
if medium._is_remote_before((1, 15)):
2640
return self._vfs_set_parent_location(url)
2642
call_url = url or ''
2643
if type(call_url) is not str:
2644
raise AssertionError('url must be a str or None (%s)' % url)
2645
response = self._call('Branch.set_parent_location',
2646
self._remote_path(), self._lock_token, self._repo_lock_token,
2648
except errors.UnknownSmartMethod:
2649
medium._remember_remote_is_before((1, 15))
2650
return self._vfs_set_parent_location(url)
2652
raise errors.UnexpectedSmartServerResponse(response)
2654
def _vfs_set_parent_location(self, url):
2656
return self._real_branch._set_parent_location(url)
1602
def get_parent(self):
1604
return self._real_branch.get_parent()
1606
def set_parent(self, url):
1608
return self._real_branch.set_parent(url)
1610
def set_stacked_on_url(self, stacked_location):
1611
"""Set the URL this branch is stacked against.
1613
:raises UnstackableBranchFormat: If the branch does not support
1615
:raises UnstackableRepositoryFormat: If the repository does not support
1619
return self._real_branch.set_stacked_on_url(stacked_location)
1621
def sprout(self, to_bzrdir, revision_id=None):
1622
# Like Branch.sprout, except that it sprouts a branch in the default
1623
# format, because RemoteBranches can't be created at arbitrary URLs.
1624
# XXX: if to_bzrdir is a RemoteBranch, this should perhaps do
1625
# to_bzrdir.create_branch...
1627
result = self._real_branch._format.initialize(to_bzrdir)
1628
self.copy_content_into(result, revision_id=revision_id)
1629
result.set_parent(self.bzrdir.root_transport.base)
2658
1632
@needs_write_lock
2659
1633
def pull(self, source, overwrite=False, stop_revision=None,
2719
1689
except errors.UnknownSmartMethod:
2720
1690
medium._remember_remote_is_before((1, 6))
2721
1691
self._clear_cached_state_of_remote_branch_only()
2722
self.set_revision_history(self._lefthand_history(revision_id,
2723
last_rev=last_rev,other_branch=other_branch))
1693
self._real_branch.generate_revision_history(
1694
revision_id, last_rev=last_rev, other_branch=other_branch)
1699
return self._real_branch.tags
2725
1701
def set_push_location(self, location):
2726
1702
self._ensure_real()
2727
1703
return self._real_branch.set_push_location(location)
2730
class RemoteConfig(object):
2731
"""A Config that reads and writes from smart verbs.
2733
It is a low-level object that considers config data to be name/value pairs
2734
that may be associated with a section. Assigning meaning to the these
2735
values is done at higher levels like bzrlib.config.TreeConfig.
2738
def get_option(self, name, section=None, default=None):
2739
"""Return the value associated with a named option.
2741
:param name: The name of the value
2742
:param section: The section the option is in (if any)
2743
:param default: The value to return if the value is not set
2744
:return: The value or default value
1706
def update_revisions(self, other, stop_revision=None, overwrite=False,
1708
"""See Branch.update_revisions."""
2747
configobj = self._get_configobj()
2749
section_obj = configobj
1711
if stop_revision is None:
1712
stop_revision = other.last_revision()
1713
if revision.is_null(stop_revision):
1714
# if there are no commits, we're done.
1716
self.fetch(other, stop_revision)
1719
# Just unconditionally set the new revision. We don't care if
1720
# the branches have diverged.
1721
self._set_last_revision(stop_revision)
2752
section_obj = configobj[section]
2755
return section_obj.get(name, default)
2756
except errors.UnknownSmartMethod:
2757
return self._vfs_get_option(name, section, default)
2759
def _response_to_configobj(self, response):
2760
if len(response[0]) and response[0][0] != 'ok':
2761
raise errors.UnexpectedSmartServerResponse(response)
2762
lines = response[1].read_body_bytes().splitlines()
2763
return config.ConfigObj(lines, encoding='utf-8')
2766
class RemoteBranchConfig(RemoteConfig):
2767
"""A RemoteConfig for Branches."""
2769
def __init__(self, branch):
2770
self._branch = branch
2772
def _get_configobj(self):
2773
path = self._branch._remote_path()
2774
response = self._branch._client.call_expecting_body(
2775
'Branch.get_config_file', path)
2776
return self._response_to_configobj(response)
2778
def set_option(self, value, name, section=None):
2779
"""Set the value associated with a named option.
2781
:param value: The value to set
2782
:param name: The name of the value to set
2783
:param section: The section the option is in (if any)
2785
medium = self._branch._client._medium
2786
if medium._is_remote_before((1, 14)):
2787
return self._vfs_set_option(value, name, section)
2789
path = self._branch._remote_path()
2790
response = self._branch._client.call('Branch.set_config_option',
2791
path, self._branch._lock_token, self._branch._repo_lock_token,
2792
value.encode('utf8'), name, section or '')
2793
except errors.UnknownSmartMethod:
2794
medium._remember_remote_is_before((1, 14))
2795
return self._vfs_set_option(value, name, section)
2797
raise errors.UnexpectedSmartServerResponse(response)
2799
def _real_object(self):
2800
self._branch._ensure_real()
2801
return self._branch._real_branch
2803
def _vfs_set_option(self, value, name, section=None):
2804
return self._real_object()._get_config().set_option(
2805
value, name, section)
2808
class RemoteBzrDirConfig(RemoteConfig):
2809
"""A RemoteConfig for BzrDirs."""
2811
def __init__(self, bzrdir):
2812
self._bzrdir = bzrdir
2814
def _get_configobj(self):
2815
medium = self._bzrdir._client._medium
2816
verb = 'BzrDir.get_config_file'
2817
if medium._is_remote_before((1, 15)):
2818
raise errors.UnknownSmartMethod(verb)
2819
path = self._bzrdir._path_for_remote_call(self._bzrdir._client)
2820
response = self._bzrdir._call_expecting_body(
2822
return self._response_to_configobj(response)
2824
def _vfs_get_option(self, name, section, default):
2825
return self._real_object()._get_config().get_option(
2826
name, section, default)
2828
def set_option(self, value, name, section=None):
2829
"""Set the value associated with a named option.
2831
:param value: The value to set
2832
:param name: The name of the value to set
2833
:param section: The section the option is in (if any)
2835
return self._real_object()._get_config().set_option(
2836
value, name, section)
2838
def _real_object(self):
2839
self._bzrdir._ensure_real()
2840
return self._bzrdir._real_bzrdir
1723
medium = self._client._medium
1724
if not medium._is_remote_before((1, 6)):
1726
self._set_last_revision_descendant(stop_revision, other)
1728
except errors.UnknownSmartMethod:
1729
medium._remember_remote_is_before((1, 6))
1730
# Fallback for pre-1.6 servers: check for divergence
1731
# client-side, then do _set_last_revision.
1732
last_rev = revision.ensure_null(self.last_revision())
1734
graph = self.repository.get_graph()
1735
if self._check_if_descendant_or_diverged(
1736
stop_revision, last_rev, graph, other):
1737
# stop_revision is a descendant of last_rev, but we aren't
1738
# overwriting, so we're done.
1740
self._set_last_revision(stop_revision)
2844
1745
def _extract_tar(tar, to_dir):
added
removed
bzrlib/remote.py
