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.
20
from cStringIO import StringIO
19
22
from bzrlib import (
31
revision as _mod_revision,
34
from bzrlib.branch import BranchReferenceFormat
29
from bzrlib.branch import Branch, BranchReferenceFormat
35
30
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
36
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
37
from bzrlib.errors import (
31
from bzrlib.config import BranchConfig, TreeConfig
32
from bzrlib.decorators import needs_read_lock, needs_write_lock
33
from bzrlib.errors import NoSuchRevision
34
from bzrlib.lockable_files import LockableFiles
35
from bzrlib.pack import ContainerReader
36
from bzrlib.smart import client, vfs
37
from bzrlib.symbol_versioning import (
41
from bzrlib.lockable_files import LockableFiles
42
from bzrlib.smart import client, vfs, repository as smart_repo
43
from bzrlib.revision import ensure_null, NULL_REVISION
44
from bzrlib.trace import mutter, note, warning
47
class _RpcHelper(object):
48
"""Mixin class that helps with issuing RPCs."""
50
def _call(self, method, *args, **err_context):
52
return self._client.call(method, *args)
53
except errors.ErrorFromSmartServer, err:
54
self._translate_error(err, **err_context)
56
def _call_expecting_body(self, method, *args, **err_context):
58
return self._client.call_expecting_body(method, *args)
59
except errors.ErrorFromSmartServer, err:
60
self._translate_error(err, **err_context)
62
def _call_with_body_bytes(self, method, args, body_bytes, **err_context):
64
return self._client.call_with_body_bytes(method, args, body_bytes)
65
except errors.ErrorFromSmartServer, err:
66
self._translate_error(err, **err_context)
68
def _call_with_body_bytes_expecting_body(self, method, args, body_bytes,
71
return self._client.call_with_body_bytes_expecting_body(
72
method, args, body_bytes)
73
except errors.ErrorFromSmartServer, err:
74
self._translate_error(err, **err_context)
77
def response_tuple_to_repo_format(response):
78
"""Convert a response tuple describing a repository format to a format."""
79
format = RemoteRepositoryFormat()
80
format._rich_root_data = (response[0] == 'yes')
81
format._supports_tree_reference = (response[1] == 'yes')
82
format._supports_external_lookups = (response[2] == 'yes')
83
format._network_name = response[3]
41
from bzrlib.trace import note
87
43
# Note: RemoteBzrDirFormat is in bzrdir.py
89
class RemoteBzrDir(BzrDir, _RpcHelper):
45
class RemoteBzrDir(BzrDir):
90
46
"""Control directory on a remote server, accessed via bzr:// or similar."""
92
def __init__(self, transport, format, _client=None, _force_probe=False):
48
def __init__(self, transport, _client=None):
93
49
"""Construct a RemoteBzrDir.
95
51
:param _client: Private parameter for testing. Disables probing and the
96
52
use of a real bzrdir.
98
BzrDir.__init__(self, transport, format)
54
BzrDir.__init__(self, transport, RemoteBzrDirFormat())
99
55
# this object holds a delegated bzrdir that uses file-level operations
100
56
# to talk to the other side
101
57
self._real_bzrdir = None
102
self._has_working_tree = None
103
# 1-shot cache for the call pattern 'create_branch; open_branch' - see
104
# create_branch for details.
105
self._next_open_branch_result = None
107
59
if _client is None:
108
medium = transport.get_smart_medium()
109
self._client = client._SmartClient(medium)
60
self._shared_medium = transport.get_shared_medium()
61
self._client = client._SmartClient(self._shared_medium)
111
63
self._client = _client
118
return '%s(%r)' % (self.__class__.__name__, self._client)
120
def _probe_bzrdir(self):
121
medium = self._client._medium
64
self._shared_medium = None
122
67
path = self._path_for_remote_call(self._client)
123
if medium._is_remote_before((2, 1)):
127
self._rpc_open_2_1(path)
129
except errors.UnknownSmartMethod:
130
medium._remember_remote_is_before((2, 1))
133
def _rpc_open_2_1(self, path):
134
response = self._call('BzrDir.open_2.1', path)
135
if response == ('no',):
136
raise errors.NotBranchError(path=self.root_transport.base)
137
elif response[0] == 'yes':
138
if response[1] == 'yes':
139
self._has_working_tree = True
140
elif response[1] == 'no':
141
self._has_working_tree = False
143
raise errors.UnexpectedSmartServerResponse(response)
145
raise errors.UnexpectedSmartServerResponse(response)
147
def _rpc_open(self, path):
148
response = self._call('BzrDir.open', path)
68
response = self._client.call('BzrDir.open', path)
149
69
if response not in [('yes',), ('no',)]:
150
70
raise errors.UnexpectedSmartServerResponse(response)
151
71
if response == ('no',):
152
raise errors.NotBranchError(path=self.root_transport.base)
72
raise errors.NotBranchError(path=transport.base)
154
74
def _ensure_real(self):
155
75
"""Ensure that there is a _real_bzrdir set.
157
77
Used before calls to self._real_bzrdir.
159
79
if not self._real_bzrdir:
160
if 'hpssvfs' in debug.debug_flags:
162
warning('VFS BzrDir access triggered\n%s',
163
''.join(traceback.format_stack()))
164
80
self._real_bzrdir = BzrDir.open_from_transport(
165
81
self.root_transport, _server_formats=False)
166
self._format._network_name = \
167
self._real_bzrdir._format.network_name()
169
def _translate_error(self, err, **context):
170
_translate_error(err, bzrdir=self, **context)
172
def break_lock(self):
173
# Prevent aliasing problems in the next_open_branch_result cache.
174
# See create_branch for rationale.
175
self._next_open_branch_result = None
176
return BzrDir.break_lock(self)
178
def _vfs_cloning_metadir(self, require_stacking=False):
180
return self._real_bzrdir.cloning_metadir(
181
require_stacking=require_stacking)
183
def cloning_metadir(self, require_stacking=False):
184
medium = self._client._medium
185
if medium._is_remote_before((1, 13)):
186
return self._vfs_cloning_metadir(require_stacking=require_stacking)
187
verb = 'BzrDir.cloning_metadir'
192
path = self._path_for_remote_call(self._client)
194
response = self._call(verb, path, stacking)
195
except errors.UnknownSmartMethod:
196
medium._remember_remote_is_before((1, 13))
197
return self._vfs_cloning_metadir(require_stacking=require_stacking)
198
except errors.UnknownErrorFromSmartServer, err:
199
if err.error_tuple != ('BranchReference',):
201
# We need to resolve the branch reference to determine the
202
# cloning_metadir. This causes unnecessary RPCs to open the
203
# referenced branch (and bzrdir, etc) but only when the caller
204
# didn't already resolve the branch reference.
205
referenced_branch = self.open_branch()
206
return referenced_branch.bzrdir.cloning_metadir()
207
if len(response) != 3:
208
raise errors.UnexpectedSmartServerResponse(response)
209
control_name, repo_name, branch_info = response
210
if len(branch_info) != 2:
211
raise errors.UnexpectedSmartServerResponse(response)
212
branch_ref, branch_name = branch_info
213
format = bzrdir.network_format_registry.get(control_name)
215
format.repository_format = repository.network_format_registry.get(
217
if branch_ref == 'ref':
218
# XXX: we need possible_transports here to avoid reopening the
219
# connection to the referenced location
220
ref_bzrdir = BzrDir.open(branch_name)
221
branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
222
format.set_branch_format(branch_format)
223
elif branch_ref == 'branch':
225
format.set_branch_format(
226
branch.network_format_registry.get(branch_name))
228
raise errors.UnexpectedSmartServerResponse(response)
231
83
def create_repository(self, shared=False):
232
# as per meta1 formats - just delegate to the format object which may
234
result = self._format.repository_format.initialize(self, shared)
235
if not isinstance(result, RemoteRepository):
236
return self.open_repository()
240
def destroy_repository(self):
241
"""See BzrDir.destroy_repository"""
243
self._real_bzrdir.destroy_repository()
245
def create_branch(self, name=None):
246
# as per meta1 formats - just delegate to the format object which may
248
real_branch = self._format.get_branch_format().initialize(self,
250
if not isinstance(real_branch, RemoteBranch):
251
result = RemoteBranch(self, self.find_repository(), real_branch,
255
# BzrDir.clone_on_transport() uses the result of create_branch but does
256
# not return it to its callers; we save approximately 8% of our round
257
# trips by handing the branch we created back to the first caller to
258
# open_branch rather than probing anew. Long term we need a API in
259
# bzrdir that doesn't discard result objects (like result_branch).
261
self._next_open_branch_result = result
264
def destroy_branch(self, name=None):
85
self._real_bzrdir.create_repository(shared=shared)
86
return self.open_repository()
88
def create_branch(self):
90
real_branch = self._real_bzrdir.create_branch()
91
return RemoteBranch(self, self.find_repository(), real_branch)
93
def destroy_branch(self):
265
94
"""See BzrDir.destroy_branch"""
266
95
self._ensure_real()
267
self._real_bzrdir.destroy_branch(name=name)
268
self._next_open_branch_result = None
96
self._real_bzrdir.destroy_branch()
270
98
def create_workingtree(self, revision_id=None, from_branch=None):
271
99
raise errors.NotLocalUrl(self.transport.base)
281
109
def get_branch_reference(self):
282
110
"""See BzrDir.get_branch_reference()."""
283
response = self._get_branch_reference()
284
if response[0] == 'ref':
289
def _get_branch_reference(self):
290
111
path = self._path_for_remote_call(self._client)
291
medium = self._client._medium
293
('BzrDir.open_branchV3', (2, 1)),
294
('BzrDir.open_branchV2', (1, 13)),
295
('BzrDir.open_branch', None),
297
for verb, required_version in candidate_calls:
298
if required_version and medium._is_remote_before(required_version):
301
response = self._call(verb, path)
302
except errors.UnknownSmartMethod:
303
if required_version is None:
305
medium._remember_remote_is_before(required_version)
308
if verb == 'BzrDir.open_branch':
309
if response[0] != 'ok':
310
raise errors.UnexpectedSmartServerResponse(response)
311
if response[1] != '':
312
return ('ref', response[1])
314
return ('branch', '')
315
if response[0] not in ('ref', 'branch'):
112
response = self._client.call('BzrDir.open_branch', path)
113
if response[0] == 'ok':
114
if response[1] == '':
115
# branch at this location.
118
# a branch reference, use the existing BranchReference logic.
120
elif response == ('nobranch',):
121
raise errors.NotBranchError(path=self.root_transport.base)
316
123
raise errors.UnexpectedSmartServerResponse(response)
319
def _get_tree_branch(self):
320
"""See BzrDir._get_tree_branch()."""
321
return None, self.open_branch()
323
def open_branch(self, name=None, unsupported=False,
324
ignore_fallbacks=False):
326
raise NotImplementedError('unsupported flag support not implemented yet.')
327
if self._next_open_branch_result is not None:
328
# See create_branch for details.
329
result = self._next_open_branch_result
330
self._next_open_branch_result = None
332
response = self._get_branch_reference()
333
if response[0] == 'ref':
125
def open_branch(self, _unsupported=False):
126
assert _unsupported == False, 'unsupported flag support not implemented yet.'
127
reference_url = self.get_branch_reference()
128
if reference_url is None:
129
# branch at this location.
130
return RemoteBranch(self, self.find_repository())
334
132
# a branch reference, use the existing BranchReference logic.
335
133
format = BranchReferenceFormat()
336
return format.open(self, name=name, _found=True,
337
location=response[1], ignore_fallbacks=ignore_fallbacks)
338
branch_format_name = response[1]
339
if not branch_format_name:
340
branch_format_name = None
341
format = RemoteBranchFormat(network_name=branch_format_name)
342
return RemoteBranch(self, self.find_repository(), format=format,
343
setup_stacking=not ignore_fallbacks, name=name)
345
def _open_repo_v1(self, path):
346
verb = 'BzrDir.find_repository'
347
response = self._call(verb, path)
348
if response[0] != 'ok':
349
raise errors.UnexpectedSmartServerResponse(response)
350
# servers that only support the v1 method don't support external
353
repo = self._real_bzrdir.open_repository()
354
response = response + ('no', repo._format.network_name())
355
return response, repo
357
def _open_repo_v2(self, path):
358
verb = 'BzrDir.find_repositoryV2'
359
response = self._call(verb, path)
360
if response[0] != 'ok':
361
raise errors.UnexpectedSmartServerResponse(response)
363
repo = self._real_bzrdir.open_repository()
364
response = response + (repo._format.network_name(),)
365
return response, repo
367
def _open_repo_v3(self, path):
368
verb = 'BzrDir.find_repositoryV3'
369
medium = self._client._medium
370
if medium._is_remote_before((1, 13)):
371
raise errors.UnknownSmartMethod(verb)
373
response = self._call(verb, path)
374
except errors.UnknownSmartMethod:
375
medium._remember_remote_is_before((1, 13))
377
if response[0] != 'ok':
378
raise errors.UnexpectedSmartServerResponse(response)
379
return response, None
134
return format.open(self, _found=True, location=reference_url)
381
136
def open_repository(self):
382
137
path = self._path_for_remote_call(self._client)
384
for probe in [self._open_repo_v3, self._open_repo_v2,
387
response, real_repo = probe(path)
389
except errors.UnknownSmartMethod:
392
raise errors.UnknownSmartMethod('BzrDir.find_repository{3,2,}')
393
if response[0] != 'ok':
394
raise errors.UnexpectedSmartServerResponse(response)
395
if len(response) != 6:
396
raise SmartProtocolError('incorrect response length %s' % (response,))
138
response = self._client.call('BzrDir.find_repository', path)
139
assert response[0] in ('ok', 'norepository'), \
140
'unexpected response code %s' % (response,)
141
if response[0] == 'norepository':
142
raise errors.NoRepositoryPresent(self)
143
assert len(response) == 4, 'incorrect response length %s' % (response,)
397
144
if response[1] == '':
398
# repo is at this dir.
399
format = response_tuple_to_repo_format(response[2:])
400
# Used to support creating a real format instance when needed.
401
format._creating_bzrdir = self
402
remote_repo = RemoteRepository(self, format)
403
format._creating_repo = remote_repo
404
if real_repo is not None:
405
remote_repo._set_real_repository(real_repo)
145
format = RemoteRepositoryFormat()
146
format.rich_root_data = (response[2] == 'yes')
147
format.supports_tree_reference = (response[3] == 'yes')
148
return RemoteRepository(self, format)
408
150
raise errors.NoRepositoryPresent(self)
410
def has_workingtree(self):
411
if self._has_working_tree is None:
413
self._has_working_tree = self._real_bzrdir.has_workingtree()
414
return self._has_working_tree
416
152
def open_workingtree(self, recommend_upgrade=True):
417
if self.has_workingtree():
154
if self._real_bzrdir.has_workingtree():
418
155
raise errors.NotLocalUrl(self.root_transport)
420
157
raise errors.NoWorkingTree(self.root_transport.base)
462
192
Instances of this repository are represented by RemoteRepository
465
The RemoteRepositoryFormat is parameterized during construction
195
The RemoteRepositoryFormat is parameterised during construction
466
196
to reflect the capabilities of the real, remote format. Specifically
467
197
the attributes rich_root_data and supports_tree_reference are set
468
198
on a per instance basis, and are not set (and should not be) at
471
:ivar _custom_format: If set, a specific concrete repository format that
472
will be used when initializing a repository with this
473
RemoteRepositoryFormat.
474
:ivar _creating_repo: If set, the repository object that this
475
RemoteRepositoryFormat was created for: it can be called into
476
to obtain data like the network name.
479
_matchingbzrdir = RemoteBzrDirFormat()
482
repository.RepositoryFormat.__init__(self)
483
self._custom_format = None
484
self._network_name = None
485
self._creating_bzrdir = None
486
self._supports_chks = None
487
self._supports_external_lookups = None
488
self._supports_tree_reference = None
489
self._rich_root_data = None
492
return "%s(_network_name=%r)" % (self.__class__.__name__,
496
def fast_deltas(self):
498
return self._custom_format.fast_deltas
501
def rich_root_data(self):
502
if self._rich_root_data is None:
504
self._rich_root_data = self._custom_format.rich_root_data
505
return self._rich_root_data
508
def supports_chks(self):
509
if self._supports_chks is None:
511
self._supports_chks = self._custom_format.supports_chks
512
return self._supports_chks
515
def supports_external_lookups(self):
516
if self._supports_external_lookups is None:
518
self._supports_external_lookups = \
519
self._custom_format.supports_external_lookups
520
return self._supports_external_lookups
523
def supports_tree_reference(self):
524
if self._supports_tree_reference is None:
526
self._supports_tree_reference = \
527
self._custom_format.supports_tree_reference
528
return self._supports_tree_reference
530
def _vfs_initialize(self, a_bzrdir, shared):
531
"""Helper for common code in initialize."""
532
if self._custom_format:
533
# Custom format requested
534
result = self._custom_format.initialize(a_bzrdir, shared=shared)
535
elif self._creating_bzrdir is not None:
536
# Use the format that the repository we were created to back
538
prior_repo = self._creating_bzrdir.open_repository()
539
prior_repo._ensure_real()
540
result = prior_repo._real_repository._format.initialize(
541
a_bzrdir, shared=shared)
543
# assume that a_bzr is a RemoteBzrDir but the smart server didn't
544
# support remote initialization.
545
# We delegate to a real object at this point (as RemoteBzrDir
546
# delegate to the repository format which would lead to infinite
547
# recursion if we just called a_bzrdir.create_repository.
548
a_bzrdir._ensure_real()
549
result = a_bzrdir._real_bzrdir.create_repository(shared=shared)
550
if not isinstance(result, RemoteRepository):
551
return self.open(a_bzrdir)
202
_matchingbzrdir = RemoteBzrDirFormat
555
204
def initialize(self, a_bzrdir, shared=False):
556
# Being asked to create on a non RemoteBzrDir:
557
if not isinstance(a_bzrdir, RemoteBzrDir):
558
return self._vfs_initialize(a_bzrdir, shared)
559
medium = a_bzrdir._client._medium
560
if medium._is_remote_before((1, 13)):
561
return self._vfs_initialize(a_bzrdir, shared)
562
# Creating on a remote bzr dir.
563
# 1) get the network name to use.
564
if self._custom_format:
565
network_name = self._custom_format.network_name()
566
elif self._network_name:
567
network_name = self._network_name
569
# Select the current bzrlib default and ask for that.
570
reference_bzrdir_format = bzrdir.format_registry.get('default')()
571
reference_format = reference_bzrdir_format.repository_format
572
network_name = reference_format.network_name()
573
# 2) try direct creation via RPC
574
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
575
verb = 'BzrDir.create_repository'
581
response = a_bzrdir._call(verb, path, network_name, shared_str)
582
except errors.UnknownSmartMethod:
583
# Fallback - use vfs methods
584
medium._remember_remote_is_before((1, 13))
585
return self._vfs_initialize(a_bzrdir, shared)
587
# Turn the response into a RemoteRepository object.
588
format = response_tuple_to_repo_format(response[1:])
589
# Used to support creating a real format instance when needed.
590
format._creating_bzrdir = a_bzrdir
591
remote_repo = RemoteRepository(a_bzrdir, format)
592
format._creating_repo = remote_repo
205
assert isinstance(a_bzrdir, RemoteBzrDir), \
206
'%r is not a RemoteBzrDir' % (a_bzrdir,)
207
return a_bzrdir.create_repository(shared=shared)
595
209
def open(self, a_bzrdir):
596
if not isinstance(a_bzrdir, RemoteBzrDir):
597
raise AssertionError('%r is not a RemoteBzrDir' % (a_bzrdir,))
210
assert isinstance(a_bzrdir, RemoteBzrDir)
598
211
return a_bzrdir.open_repository()
600
def _ensure_real(self):
601
if self._custom_format is None:
602
self._custom_format = repository.network_format_registry.get(
606
def _fetch_order(self):
608
return self._custom_format._fetch_order
611
def _fetch_uses_deltas(self):
613
return self._custom_format._fetch_uses_deltas
616
def _fetch_reconcile(self):
618
return self._custom_format._fetch_reconcile
620
213
def get_format_description(self):
622
return 'Remote: ' + self._custom_format.get_format_description()
214
return 'bzr remote repository'
624
216
def __eq__(self, other):
625
return self.__class__ is other.__class__
627
def network_name(self):
628
if self._network_name:
629
return self._network_name
630
self._creating_repo._ensure_real()
631
return self._creating_repo._real_repository._format.network_name()
634
def pack_compresses(self):
636
return self._custom_format.pack_compresses
639
def _serializer(self):
641
return self._custom_format._serializer
644
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin):
217
return self.__class__ == other.__class__
219
def check_conversion_target(self, target_format):
220
if self.rich_root_data and not target_format.rich_root_data:
221
raise errors.BadConversionTarget(
222
'Does not support rich root data.', target_format)
223
if (self.supports_tree_reference and
224
not getattr(target_format, 'supports_tree_reference', False)):
225
raise errors.BadConversionTarget(
226
'Does not support nested trees', target_format)
229
class RemoteRepository(object):
645
230
"""Repository accessed over rpc.
647
232
For the moment most operations are performed using local transport-backed
730
295
self._ensure_real()
731
296
return self._real_repository.commit_write_group()
733
def resume_write_group(self, tokens):
735
return self._real_repository.resume_write_group(tokens)
737
def suspend_write_group(self):
739
return self._real_repository.suspend_write_group()
741
def get_missing_parent_inventories(self, check_for_missing_texts=True):
743
return self._real_repository.get_missing_parent_inventories(
744
check_for_missing_texts=check_for_missing_texts)
746
def _get_rev_id_for_revno_vfs(self, revno, known_pair):
748
return self._real_repository.get_rev_id_for_revno(
751
def get_rev_id_for_revno(self, revno, known_pair):
752
"""See Repository.get_rev_id_for_revno."""
753
path = self.bzrdir._path_for_remote_call(self._client)
755
if self._client._medium._is_remote_before((1, 17)):
756
return self._get_rev_id_for_revno_vfs(revno, known_pair)
757
response = self._call(
758
'Repository.get_rev_id_for_revno', path, revno, known_pair)
759
except errors.UnknownSmartMethod:
760
self._client._medium._remember_remote_is_before((1, 17))
761
return self._get_rev_id_for_revno_vfs(revno, known_pair)
762
if response[0] == 'ok':
763
return True, response[1]
764
elif response[0] == 'history-incomplete':
765
known_pair = response[1:3]
766
for fallback in self._fallback_repositories:
767
found, result = fallback.get_rev_id_for_revno(revno, known_pair)
772
# Not found in any fallbacks
773
return False, known_pair
775
raise errors.UnexpectedSmartServerResponse(response)
777
298
def _ensure_real(self):
778
299
"""Ensure that there is a _real_repository set.
780
301
Used before calls to self._real_repository.
782
Note that _ensure_real causes many roundtrips to the server which are
783
not desirable, and prevents the use of smart one-roundtrip RPC's to
784
perform complex operations (such as accessing parent data, streaming
785
revisions etc). Adding calls to _ensure_real should only be done when
786
bringing up new functionality, adding fallbacks for smart methods that
787
require a fallback path, and never to replace an existing smart method
788
invocation. If in doubt chat to the bzr network team.
790
if self._real_repository is None:
791
if 'hpssvfs' in debug.debug_flags:
793
warning('VFS Repository access triggered\n%s',
794
''.join(traceback.format_stack()))
795
self._unstacked_provider.missing_keys.clear()
303
if not self._real_repository:
796
304
self.bzrdir._ensure_real()
797
self._set_real_repository(
798
self.bzrdir._real_bzrdir.open_repository())
800
def _translate_error(self, err, **context):
801
self.bzrdir._translate_error(err, repository=self, **context)
305
#self._real_repository = self.bzrdir._real_bzrdir.open_repository()
306
self._set_real_repository(self.bzrdir._real_bzrdir.open_repository())
803
308
def find_text_key_references(self):
804
309
"""Find the text key references within the repository.
825
330
self._ensure_real()
826
331
return self._real_repository._generate_text_key_index()
828
def _get_revision_graph(self, revision_id):
829
"""Private method for using with old (< 1.2) servers to fallback."""
333
def get_revision_graph(self, revision_id=None):
334
"""See Repository.get_revision_graph()."""
830
335
if revision_id is None:
832
337
elif revision.is_null(revision_id):
835
340
path = self.bzrdir._path_for_remote_call(self._client)
836
response = self._call_expecting_body(
341
assert type(revision_id) is str
342
response = self._client.call_expecting_body(
837
343
'Repository.get_revision_graph', path, revision_id)
838
response_tuple, response_handler = response
839
if response_tuple[0] != 'ok':
840
raise errors.UnexpectedSmartServerResponse(response_tuple)
841
coded = response_handler.read_body_bytes()
843
# no revisions in this repository!
845
lines = coded.split('\n')
848
d = tuple(line.split())
849
revision_graph[d[0]] = d[1:]
851
return revision_graph
854
"""See Repository._get_sink()."""
855
return RemoteStreamSink(self)
857
def _get_source(self, to_format):
858
"""Return a source for streaming from this repository."""
859
return RemoteStreamSource(self, to_format)
344
if response[0][0] not in ['ok', 'nosuchrevision']:
345
raise errors.UnexpectedSmartServerResponse(response[0])
346
if response[0][0] == 'ok':
347
coded = response[1].read_body_bytes()
349
# no revisions in this repository!
351
lines = coded.split('\n')
354
d = tuple(line.split())
355
revision_graph[d[0]] = d[1:]
357
return revision_graph
359
response_body = response[1].read_body_bytes()
360
assert response_body == ''
361
raise NoSuchRevision(self, revision_id)
862
363
def has_revision(self, revision_id):
863
"""True if this repository has a copy of the revision."""
864
# Copy of bzrlib.repository.Repository.has_revision
865
return revision_id in self.has_revisions((revision_id,))
868
def has_revisions(self, revision_ids):
869
"""Probe to find out the presence of multiple revisions.
871
:param revision_ids: An iterable of revision_ids.
872
:return: A set of the revision_ids that were present.
874
# Copy of bzrlib.repository.Repository.has_revisions
875
parent_map = self.get_parent_map(revision_ids)
876
result = set(parent_map)
877
if _mod_revision.NULL_REVISION in revision_ids:
878
result.add(_mod_revision.NULL_REVISION)
881
def _has_same_fallbacks(self, other_repo):
882
"""Returns true if the repositories have the same fallbacks."""
883
# XXX: copied from Repository; it should be unified into a base class
884
# <https://bugs.edge.launchpad.net/bzr/+bug/401622>
885
my_fb = self._fallback_repositories
886
other_fb = other_repo._fallback_repositories
887
if len(my_fb) != len(other_fb):
889
for f, g in zip(my_fb, other_fb):
890
if not f.has_same_location(g):
364
"""See Repository.has_revision()."""
365
if revision_id is None:
366
# The null revision is always present.
368
path = self.bzrdir._path_for_remote_call(self._client)
369
response = self._client.call('Repository.has_revision', path, revision_id)
370
assert response[0] in ('yes', 'no'), 'unexpected response code %s' % (response,)
371
return response[0] == 'yes'
894
373
def has_same_location(self, other):
895
# TODO: Move to RepositoryBase and unify with the regular Repository
896
# one; unfortunately the tests rely on slightly different behaviour at
897
# present -- mbp 20090710
898
return (self.__class__ is other.__class__ and
374
return (self.__class__ == other.__class__ and
899
375
self.bzrdir.transport.base == other.bzrdir.transport.base)
901
377
def get_graph(self, other_repository=None):
902
378
"""Return the graph for this repository format"""
903
parents_provider = self._make_parents_provider(other_repository)
904
return graph.Graph(parents_provider)
380
return self._real_repository.get_graph(other_repository)
906
382
def gather_stats(self, revid=None, committers=None):
907
383
"""See Repository.gather_stats()."""
1195
610
# FIXME: It ought to be possible to call this without immediately
1196
611
# triggering _ensure_real. For now it's the easiest thing to do.
1197
612
self._ensure_real()
1198
real_repo = self._real_repository
1199
builder = real_repo.get_commit_builder(branch, parents,
613
builder = self._real_repository.get_commit_builder(branch, parents,
1200
614
config, timestamp=timestamp, timezone=timezone,
1201
615
committer=committer, revprops=revprops, revision_id=revision_id)
1204
def add_fallback_repository(self, repository):
1205
"""Add a repository to use for looking up data not held locally.
1207
:param repository: A repository.
1209
if not self._format.supports_external_lookups:
1210
raise errors.UnstackableRepositoryFormat(
1211
self._format.network_name(), self.base)
1212
# We need to accumulate additional repositories here, to pass them in
1215
if self.is_locked():
1216
# We will call fallback.unlock() when we transition to the unlocked
1217
# state, so always add a lock here. If a caller passes us a locked
1218
# repository, they are responsible for unlocking it later.
1219
repository.lock_read()
1220
self._fallback_repositories.append(repository)
1221
# If self._real_repository was parameterised already (e.g. because a
1222
# _real_branch had its get_stacked_on_url method called), then the
1223
# repository to be added may already be in the _real_repositories list.
1224
if self._real_repository is not None:
1225
fallback_locations = [repo.bzrdir.root_transport.base for repo in
1226
self._real_repository._fallback_repositories]
1227
if repository.bzrdir.root_transport.base not in fallback_locations:
1228
self._real_repository.add_fallback_repository(repository)
1230
619
def add_inventory(self, revid, inv, parents):
1231
620
self._ensure_real()
1232
621
return self._real_repository.add_inventory(revid, inv, parents)
1234
def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1235
parents, basis_inv=None, propagate_caches=False):
1237
return self._real_repository.add_inventory_by_delta(basis_revision_id,
1238
delta, new_revision_id, parents, basis_inv=basis_inv,
1239
propagate_caches=propagate_caches)
1241
624
def add_revision(self, rev_id, rev, inv=None, config=None):
1242
625
self._ensure_real()
1243
626
return self._real_repository.add_revision(
1267
651
return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
1269
653
def make_working_trees(self):
1270
"""See Repository.make_working_trees"""
1272
return self._real_repository.make_working_trees()
1274
def refresh_data(self):
1275
"""Re-read any data needed to to synchronise with disk.
1277
This method is intended to be called after another repository instance
1278
(such as one used by a smart server) has inserted data into the
1279
repository. It may not be called during a write group, but may be
1280
called at any other time.
1282
if self.is_in_write_group():
1283
raise errors.InternalBzrError(
1284
"May not refresh_data while in a write group.")
1285
if self._real_repository is not None:
1286
self._real_repository.refresh_data()
1288
def revision_ids_to_search_result(self, result_set):
1289
"""Convert a set of revision ids to a graph SearchResult."""
1290
result_parents = set()
1291
for parents in self.get_graph().get_parent_map(
1292
result_set).itervalues():
1293
result_parents.update(parents)
1294
included_keys = result_set.intersection(result_parents)
1295
start_keys = result_set.difference(included_keys)
1296
exclude_keys = result_parents.difference(result_set)
1297
result = graph.SearchResult(start_keys, exclude_keys,
1298
len(result_set), result_set)
1302
def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1303
"""Return the revision ids that other has that this does not.
1305
These are returned in topological order.
1307
revision_id: only return revision ids included by revision_id.
1309
return repository.InterRepository.get(
1310
other, self).search_missing_revision_ids(revision_id, find_ghosts)
1312
def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
1314
# No base implementation to use as RemoteRepository is not a subclass
1315
# of Repository; so this is a copy of Repository.fetch().
1316
if fetch_spec is not None and revision_id is not None:
1317
raise AssertionError(
1318
"fetch_spec and revision_id are mutually exclusive.")
1319
if self.is_in_write_group():
1320
raise errors.InternalBzrError(
1321
"May not fetch while in a write group.")
1322
# fast path same-url fetch operations
1323
if (self.has_same_location(source)
1324
and fetch_spec is None
1325
and self._has_same_fallbacks(source)):
654
"""RemoteRepositories never create working trees by default."""
657
def fetch(self, source, revision_id=None, pb=None):
658
if self.has_same_location(source):
1326
659
# check that last_revision is in 'from' and then return a
1328
661
if (revision_id is not None and
1329
662
not revision.is_null(revision_id)):
1330
663
self.get_revision(revision_id)
1332
# if there is no specific appropriate InterRepository, this will get
1333
# the InterRepository base class, which raises an
1334
# IncompatibleRepositories when asked to fetch.
1335
inter = repository.InterRepository.get(source, self)
1336
return inter.fetch(revision_id=revision_id, pb=pb,
1337
find_ghosts=find_ghosts, fetch_spec=fetch_spec)
666
return self._real_repository.fetch(
667
source, revision_id=revision_id, pb=pb)
1339
669
def create_bundle(self, target, base, fileobj, format=None):
1340
670
self._ensure_real()
1341
671
self._real_repository.create_bundle(target, base, fileobj, format)
674
def control_weaves(self):
676
return self._real_repository.control_weaves
1343
678
@needs_read_lock
1344
679
def get_ancestry(self, revision_id, topo_sorted=True):
1345
680
self._ensure_real()
1346
681
return self._real_repository.get_ancestry(revision_id, topo_sorted)
684
def get_inventory_weave(self):
686
return self._real_repository.get_inventory_weave()
1348
688
def fileids_altered_by_revision_ids(self, revision_ids):
1349
689
self._ensure_real()
1350
690
return self._real_repository.fileids_altered_by_revision_ids(revision_ids)
1352
def _get_versioned_file_checker(self, revisions, revision_versions_cache):
692
def get_versioned_file_checker(self, revisions, revision_versions_cache):
1353
693
self._ensure_real()
1354
return self._real_repository._get_versioned_file_checker(
694
return self._real_repository.get_versioned_file_checker(
1355
695
revisions, revision_versions_cache)
1357
697
def iter_files_bytes(self, desired_files):
1358
698
"""See Repository.iter_file_bytes.
1360
700
self._ensure_real()
1361
701
return self._real_repository.iter_files_bytes(desired_files)
1363
def get_parent_map(self, revision_ids):
1364
"""See bzrlib.Graph.get_parent_map()."""
1365
return self._make_parents_provider().get_parent_map(revision_ids)
1367
def _get_parent_map_rpc(self, keys):
1368
"""Helper for get_parent_map that performs the RPC."""
1369
medium = self._client._medium
1370
if medium._is_remote_before((1, 2)):
1371
# We already found out that the server can't understand
1372
# Repository.get_parent_map requests, so just fetch the whole
1375
# Note that this reads the whole graph, when only some keys are
1376
# wanted. On this old server there's no way (?) to get them all
1377
# in one go, and the user probably will have seen a warning about
1378
# the server being old anyhow.
1379
rg = self._get_revision_graph(None)
1380
# There is an API discrepancy between get_parent_map and
1381
# get_revision_graph. Specifically, a "key:()" pair in
1382
# get_revision_graph just means a node has no parents. For
1383
# "get_parent_map" it means the node is a ghost. So fix up the
1384
# graph to correct this.
1385
# https://bugs.launchpad.net/bzr/+bug/214894
1386
# There is one other "bug" which is that ghosts in
1387
# get_revision_graph() are not returned at all. But we won't worry
1388
# about that for now.
1389
for node_id, parent_ids in rg.iteritems():
1390
if parent_ids == ():
1391
rg[node_id] = (NULL_REVISION,)
1392
rg[NULL_REVISION] = ()
1397
raise ValueError('get_parent_map(None) is not valid')
1398
if NULL_REVISION in keys:
1399
keys.discard(NULL_REVISION)
1400
found_parents = {NULL_REVISION:()}
1402
return found_parents
1405
# TODO(Needs analysis): We could assume that the keys being requested
1406
# from get_parent_map are in a breadth first search, so typically they
1407
# will all be depth N from some common parent, and we don't have to
1408
# have the server iterate from the root parent, but rather from the
1409
# keys we're searching; and just tell the server the keyspace we
1410
# already have; but this may be more traffic again.
1412
# Transform self._parents_map into a search request recipe.
1413
# TODO: Manage this incrementally to avoid covering the same path
1414
# repeatedly. (The server will have to on each request, but the less
1415
# work done the better).
1417
# Negative caching notes:
1418
# new server sends missing when a request including the revid
1419
# 'include-missing:' is present in the request.
1420
# missing keys are serialised as missing:X, and we then call
1421
# provider.note_missing(X) for-all X
1422
parents_map = self._unstacked_provider.get_cached_map()
1423
if parents_map is None:
1424
# Repository is not locked, so there's no cache.
1426
# start_set is all the keys in the cache
1427
start_set = set(parents_map)
1428
# result set is all the references to keys in the cache
1429
result_parents = set()
1430
for parents in parents_map.itervalues():
1431
result_parents.update(parents)
1432
stop_keys = result_parents.difference(start_set)
1433
# We don't need to send ghosts back to the server as a position to
1435
stop_keys.difference_update(self._unstacked_provider.missing_keys)
1436
key_count = len(parents_map)
1437
if (NULL_REVISION in result_parents
1438
and NULL_REVISION in self._unstacked_provider.missing_keys):
1439
# If we pruned NULL_REVISION from the stop_keys because it's also
1440
# in our cache of "missing" keys we need to increment our key count
1441
# by 1, because the reconsitituted SearchResult on the server will
1442
# still consider NULL_REVISION to be an included key.
1444
included_keys = start_set.intersection(result_parents)
1445
start_set.difference_update(included_keys)
1446
recipe = ('manual', start_set, stop_keys, key_count)
1447
body = self._serialise_search_recipe(recipe)
1448
path = self.bzrdir._path_for_remote_call(self._client)
1450
if type(key) is not str:
1452
"key %r not a plain string" % (key,))
1453
verb = 'Repository.get_parent_map'
1454
args = (path, 'include-missing:') + tuple(keys)
1456
response = self._call_with_body_bytes_expecting_body(
1458
except errors.UnknownSmartMethod:
1459
# Server does not support this method, so get the whole graph.
1460
# Worse, we have to force a disconnection, because the server now
1461
# doesn't realise it has a body on the wire to consume, so the
1462
# only way to recover is to abandon the connection.
1464
'Server is too old for fast get_parent_map, reconnecting. '
1465
'(Upgrade the server to Bazaar 1.2 to avoid this)')
1467
# To avoid having to disconnect repeatedly, we keep track of the
1468
# fact the server doesn't understand remote methods added in 1.2.
1469
medium._remember_remote_is_before((1, 2))
1470
# Recurse just once and we should use the fallback code.
1471
return self._get_parent_map_rpc(keys)
1472
response_tuple, response_handler = response
1473
if response_tuple[0] not in ['ok']:
1474
response_handler.cancel_read_body()
1475
raise errors.UnexpectedSmartServerResponse(response_tuple)
1476
if response_tuple[0] == 'ok':
1477
coded = bz2.decompress(response_handler.read_body_bytes())
1479
# no revisions found
1481
lines = coded.split('\n')
1484
d = tuple(line.split())
1486
revision_graph[d[0]] = d[1:]
1489
if d[0].startswith('missing:'):
1491
self._unstacked_provider.note_missing_key(revid)
1493
# no parents - so give the Graph result
1495
revision_graph[d[0]] = (NULL_REVISION,)
1496
return revision_graph
1498
703
@needs_read_lock
1499
704
def get_signature_text(self, revision_id):
1500
705
self._ensure_real()
1501
706
return self._real_repository.get_signature_text(revision_id)
1503
708
@needs_read_lock
1504
def _get_inventory_xml(self, revision_id):
1506
return self._real_repository._get_inventory_xml(revision_id)
709
def get_revision_graph_with_ghosts(self, revision_ids=None):
711
return self._real_repository.get_revision_graph_with_ghosts(
712
revision_ids=revision_ids)
715
def get_inventory_xml(self, revision_id):
717
return self._real_repository.get_inventory_xml(revision_id)
719
def deserialise_inventory(self, revision_id, xml):
721
return self._real_repository.deserialise_inventory(revision_id, xml)
1508
723
def reconcile(self, other=None, thorough=False):
1509
724
self._ensure_real()
1510
725
return self._real_repository.reconcile(other=other, thorough=thorough)
1512
727
def all_revision_ids(self):
1513
728
self._ensure_real()
1514
729
return self._real_repository.all_revision_ids()
1517
def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1519
return self._real_repository.get_deltas_for_revisions(revisions,
1520
specific_fileids=specific_fileids)
1523
def get_revision_delta(self, revision_id, specific_fileids=None):
1525
return self._real_repository.get_revision_delta(revision_id,
1526
specific_fileids=specific_fileids)
732
def get_deltas_for_revisions(self, revisions):
734
return self._real_repository.get_deltas_for_revisions(revisions)
737
def get_revision_delta(self, revision_id):
739
return self._real_repository.get_revision_delta(revision_id)
1528
741
@needs_read_lock
1529
742
def revision_trees(self, revision_ids):
1685
880
self._ensure_real()
1686
881
return self._real_repository.revision_graph_can_have_wrong_parents()
1688
def _find_inconsistent_revision_parents(self, revisions_iterator=None):
883
def _find_inconsistent_revision_parents(self):
1689
884
self._ensure_real()
1690
return self._real_repository._find_inconsistent_revision_parents(
885
return self._real_repository._find_inconsistent_revision_parents()
1693
887
def _check_for_inconsistent_revision_parents(self):
1694
888
self._ensure_real()
1695
889
return self._real_repository._check_for_inconsistent_revision_parents()
1697
def _make_parents_provider(self, other=None):
1698
providers = [self._unstacked_provider]
1699
if other is not None:
1700
providers.insert(0, other)
1701
providers.extend(r._make_parents_provider() for r in
1702
self._fallback_repositories)
1703
return graph.StackedParentsProvider(providers)
1705
def _serialise_search_recipe(self, recipe):
1706
"""Serialise a graph search recipe.
1708
:param recipe: A search recipe (start, stop, count).
1709
:return: Serialised bytes.
1711
start_keys = ' '.join(recipe[1])
1712
stop_keys = ' '.join(recipe[2])
1713
count = str(recipe[3])
1714
return '\n'.join((start_keys, stop_keys, count))
1716
def _serialise_search_result(self, search_result):
1717
if isinstance(search_result, graph.PendingAncestryResult):
1718
parts = ['ancestry-of']
1719
parts.extend(search_result.heads)
1721
recipe = search_result.get_recipe()
1722
parts = [recipe[0], self._serialise_search_recipe(recipe)]
1723
return '\n'.join(parts)
1726
path = self.bzrdir._path_for_remote_call(self._client)
1728
response = self._call('PackRepository.autopack', path)
1729
except errors.UnknownSmartMethod:
1731
self._real_repository._pack_collection.autopack()
1734
if response[0] != 'ok':
1735
raise errors.UnexpectedSmartServerResponse(response)
1738
class RemoteStreamSink(repository.StreamSink):
1740
def _insert_real(self, stream, src_format, resume_tokens):
1741
self.target_repo._ensure_real()
1742
sink = self.target_repo._real_repository._get_sink()
1743
result = sink.insert_stream(stream, src_format, resume_tokens)
1745
self.target_repo.autopack()
1748
def insert_stream(self, stream, src_format, resume_tokens):
1749
target = self.target_repo
1750
target._unstacked_provider.missing_keys.clear()
1751
candidate_calls = [('Repository.insert_stream_1.19', (1, 19))]
1752
if target._lock_token:
1753
candidate_calls.append(('Repository.insert_stream_locked', (1, 14)))
1754
lock_args = (target._lock_token or '',)
1756
candidate_calls.append(('Repository.insert_stream', (1, 13)))
1758
client = target._client
1759
medium = client._medium
1760
path = target.bzrdir._path_for_remote_call(client)
1761
# Probe for the verb to use with an empty stream before sending the
1762
# real stream to it. We do this both to avoid the risk of sending a
1763
# large request that is then rejected, and because we don't want to
1764
# implement a way to buffer, rewind, or restart the stream.
1766
for verb, required_version in candidate_calls:
1767
if medium._is_remote_before(required_version):
1770
# We've already done the probing (and set _is_remote_before) on
1771
# a previous insert.
1774
byte_stream = smart_repo._stream_to_byte_stream([], src_format)
1776
response = client.call_with_body_stream(
1777
(verb, path, '') + lock_args, byte_stream)
1778
except errors.UnknownSmartMethod:
1779
medium._remember_remote_is_before(required_version)
1785
return self._insert_real(stream, src_format, resume_tokens)
1786
self._last_inv_record = None
1787
self._last_substream = None
1788
if required_version < (1, 19):
1789
# Remote side doesn't support inventory deltas. Wrap the stream to
1790
# make sure we don't send any. If the stream contains inventory
1791
# deltas we'll interrupt the smart insert_stream request and
1793
stream = self._stop_stream_if_inventory_delta(stream)
1794
byte_stream = smart_repo._stream_to_byte_stream(
1796
resume_tokens = ' '.join(resume_tokens)
1797
response = client.call_with_body_stream(
1798
(verb, path, resume_tokens) + lock_args, byte_stream)
1799
if response[0][0] not in ('ok', 'missing-basis'):
1800
raise errors.UnexpectedSmartServerResponse(response)
1801
if self._last_substream is not None:
1802
# The stream included an inventory-delta record, but the remote
1803
# side isn't new enough to support them. So we need to send the
1804
# rest of the stream via VFS.
1805
self.target_repo.refresh_data()
1806
return self._resume_stream_with_vfs(response, src_format)
1807
if response[0][0] == 'missing-basis':
1808
tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1809
resume_tokens = tokens
1810
return resume_tokens, set(missing_keys)
1812
self.target_repo.refresh_data()
1815
def _resume_stream_with_vfs(self, response, src_format):
1816
"""Resume sending a stream via VFS, first resending the record and
1817
substream that couldn't be sent via an insert_stream verb.
1819
if response[0][0] == 'missing-basis':
1820
tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1821
# Ignore missing_keys, we haven't finished inserting yet
1824
def resume_substream():
1825
# Yield the substream that was interrupted.
1826
for record in self._last_substream:
1828
self._last_substream = None
1829
def resume_stream():
1830
# Finish sending the interrupted substream
1831
yield ('inventory-deltas', resume_substream())
1832
# Then simply continue sending the rest of the stream.
1833
for substream_kind, substream in self._last_stream:
1834
yield substream_kind, substream
1835
return self._insert_real(resume_stream(), src_format, tokens)
1837
def _stop_stream_if_inventory_delta(self, stream):
1838
"""Normally this just lets the original stream pass-through unchanged.
1840
However if any 'inventory-deltas' substream occurs it will stop
1841
streaming, and store the interrupted substream and stream in
1842
self._last_substream and self._last_stream so that the stream can be
1843
resumed by _resume_stream_with_vfs.
1846
stream_iter = iter(stream)
1847
for substream_kind, substream in stream_iter:
1848
if substream_kind == 'inventory-deltas':
1849
self._last_substream = substream
1850
self._last_stream = stream_iter
1853
yield substream_kind, substream
1856
class RemoteStreamSource(repository.StreamSource):
1857
"""Stream data from a remote server."""
1859
def get_stream(self, search):
1860
if (self.from_repository._fallback_repositories and
1861
self.to_format._fetch_order == 'topological'):
1862
return self._real_stream(self.from_repository, search)
1865
repos = [self.from_repository]
1871
repos.extend(repo._fallback_repositories)
1872
sources.append(repo)
1873
return self.missing_parents_chain(search, sources)
1875
def get_stream_for_missing_keys(self, missing_keys):
1876
self.from_repository._ensure_real()
1877
real_repo = self.from_repository._real_repository
1878
real_source = real_repo._get_source(self.to_format)
1879
return real_source.get_stream_for_missing_keys(missing_keys)
1881
def _real_stream(self, repo, search):
1882
"""Get a stream for search from repo.
1884
This never called RemoteStreamSource.get_stream, and is a heler
1885
for RemoteStreamSource._get_stream to allow getting a stream
1886
reliably whether fallback back because of old servers or trying
1887
to stream from a non-RemoteRepository (which the stacked support
1890
source = repo._get_source(self.to_format)
1891
if isinstance(source, RemoteStreamSource):
1893
source = repo._real_repository._get_source(self.to_format)
1894
return source.get_stream(search)
1896
def _get_stream(self, repo, search):
1897
"""Core worker to get a stream from repo for search.
1899
This is used by both get_stream and the stacking support logic. It
1900
deliberately gets a stream for repo which does not need to be
1901
self.from_repository. In the event that repo is not Remote, or
1902
cannot do a smart stream, a fallback is made to the generic
1903
repository._get_stream() interface, via self._real_stream.
1905
In the event of stacking, streams from _get_stream will not
1906
contain all the data for search - this is normal (see get_stream).
1908
:param repo: A repository.
1909
:param search: A search.
1911
# Fallbacks may be non-smart
1912
if not isinstance(repo, RemoteRepository):
1913
return self._real_stream(repo, search)
1914
client = repo._client
1915
medium = client._medium
1916
path = repo.bzrdir._path_for_remote_call(client)
1917
search_bytes = repo._serialise_search_result(search)
1918
args = (path, self.to_format.network_name())
1920
('Repository.get_stream_1.19', (1, 19)),
1921
('Repository.get_stream', (1, 13))]
1923
for verb, version in candidate_verbs:
1924
if medium._is_remote_before(version):
1927
response = repo._call_with_body_bytes_expecting_body(
1928
verb, args, search_bytes)
1929
except errors.UnknownSmartMethod:
1930
medium._remember_remote_is_before(version)
1932
response_tuple, response_handler = response
1936
return self._real_stream(repo, search)
1937
if response_tuple[0] != 'ok':
1938
raise errors.UnexpectedSmartServerResponse(response_tuple)
1939
byte_stream = response_handler.read_streamed_body()
1940
src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
1941
if src_format.network_name() != repo._format.network_name():
1942
raise AssertionError(
1943
"Mismatched RemoteRepository and stream src %r, %r" % (
1944
src_format.network_name(), repo._format.network_name()))
1947
def missing_parents_chain(self, search, sources):
1948
"""Chain multiple streams together to handle stacking.
1950
:param search: The overall search to satisfy with streams.
1951
:param sources: A list of Repository objects to query.
1953
self.from_serialiser = self.from_repository._format._serializer
1954
self.seen_revs = set()
1955
self.referenced_revs = set()
1956
# If there are heads in the search, or the key count is > 0, we are not
1958
while not search.is_empty() and len(sources) > 1:
1959
source = sources.pop(0)
1960
stream = self._get_stream(source, search)
1961
for kind, substream in stream:
1962
if kind != 'revisions':
1963
yield kind, substream
1965
yield kind, self.missing_parents_rev_handler(substream)
1966
search = search.refine(self.seen_revs, self.referenced_revs)
1967
self.seen_revs = set()
1968
self.referenced_revs = set()
1969
if not search.is_empty():
1970
for kind, stream in self._get_stream(sources[0], search):
1973
def missing_parents_rev_handler(self, substream):
1974
for content in substream:
1975
revision_bytes = content.get_bytes_as('fulltext')
1976
revision = self.from_serialiser.read_revision_from_string(
1978
self.seen_revs.add(content.key[-1])
1979
self.referenced_revs.update(revision.parent_ids)
1983
892
class RemoteBranchLockableFiles(LockableFiles):
1984
893
"""A 'LockableFiles' implementation that talks to a smart server.
1986
895
This is not a public interface class.
1999
908
self._dir_mode = None
2000
909
self._file_mode = None
912
"""'get' a remote path as per the LockableFiles interface.
914
:param path: the file to 'get'. If this is 'branch.conf', we do not
915
just retrieve a file, instead we ask the smart server to generate
916
a configuration for us - which is retrieved as an INI file.
918
if path == 'branch.conf':
919
path = self.bzrdir._path_for_remote_call(self._client)
920
response = self._client.call_expecting_body(
921
'Branch.get_config_file', path)
922
assert response[0][0] == 'ok', \
923
'unexpected response code %s' % (response[0],)
924
return StringIO(response[1].read_body_bytes())
927
return LockableFiles.get(self, path)
2003
930
class RemoteBranchFormat(branch.BranchFormat):
2005
def __init__(self, network_name=None):
2006
super(RemoteBranchFormat, self).__init__()
2007
self._matchingbzrdir = RemoteBzrDirFormat()
2008
self._matchingbzrdir.set_branch_format(self)
2009
self._custom_format = None
2010
self._network_name = network_name
2012
932
def __eq__(self, other):
2013
return (isinstance(other, RemoteBranchFormat) and
933
return (isinstance(other, RemoteBranchFormat) and
2014
934
self.__dict__ == other.__dict__)
2016
def _ensure_real(self):
2017
if self._custom_format is None:
2018
self._custom_format = branch.network_format_registry.get(
2021
936
def get_format_description(self):
2023
return 'Remote: ' + self._custom_format.get_format_description()
2025
def network_name(self):
2026
return self._network_name
2028
def open(self, a_bzrdir, name=None, ignore_fallbacks=False):
2029
return a_bzrdir.open_branch(name=name,
2030
ignore_fallbacks=ignore_fallbacks)
2032
def _vfs_initialize(self, a_bzrdir, name):
2033
# Initialisation when using a local bzrdir object, or a non-vfs init
2034
# method is not available on the server.
2035
# self._custom_format is always set - the start of initialize ensures
2037
if isinstance(a_bzrdir, RemoteBzrDir):
2038
a_bzrdir._ensure_real()
2039
result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2042
# We assume the bzrdir is parameterised; it may not be.
2043
result = self._custom_format.initialize(a_bzrdir, name)
2044
if (isinstance(a_bzrdir, RemoteBzrDir) and
2045
not isinstance(result, RemoteBranch)):
2046
result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2050
def initialize(self, a_bzrdir, name=None):
2051
# 1) get the network name to use.
2052
if self._custom_format:
2053
network_name = self._custom_format.network_name()
2055
# Select the current bzrlib default and ask for that.
2056
reference_bzrdir_format = bzrdir.format_registry.get('default')()
2057
reference_format = reference_bzrdir_format.get_branch_format()
2058
self._custom_format = reference_format
2059
network_name = reference_format.network_name()
2060
# Being asked to create on a non RemoteBzrDir:
2061
if not isinstance(a_bzrdir, RemoteBzrDir):
2062
return self._vfs_initialize(a_bzrdir, name=name)
2063
medium = a_bzrdir._client._medium
2064
if medium._is_remote_before((1, 13)):
2065
return self._vfs_initialize(a_bzrdir, name=name)
2066
# Creating on a remote bzr dir.
2067
# 2) try direct creation via RPC
2068
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2069
if name is not None:
2070
# XXX JRV20100304: Support creating colocated branches
2071
raise errors.NoColocatedBranchSupport(self)
2072
verb = 'BzrDir.create_branch'
2074
response = a_bzrdir._call(verb, path, network_name)
2075
except errors.UnknownSmartMethod:
2076
# Fallback - use vfs methods
2077
medium._remember_remote_is_before((1, 13))
2078
return self._vfs_initialize(a_bzrdir, name=name)
2079
if response[0] != 'ok':
2080
raise errors.UnexpectedSmartServerResponse(response)
2081
# Turn the response into a RemoteRepository object.
2082
format = RemoteBranchFormat(network_name=response[1])
2083
repo_format = response_tuple_to_repo_format(response[3:])
2084
if response[2] == '':
2085
repo_bzrdir = a_bzrdir
2087
repo_bzrdir = RemoteBzrDir(
2088
a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
2090
remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2091
remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2092
format=format, setup_stacking=False, name=name)
2093
# XXX: We know this is a new branch, so it must have revno 0, revid
2094
# NULL_REVISION. Creating the branch locked would make this be unable
2095
# to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2096
remote_branch._last_revision_info_cache = 0, NULL_REVISION
2097
return remote_branch
2099
def make_tags(self, branch):
2101
return self._custom_format.make_tags(branch)
937
return 'Remote BZR Branch'
939
def get_format_string(self):
940
return 'Remote BZR Branch'
942
def open(self, a_bzrdir):
943
assert isinstance(a_bzrdir, RemoteBzrDir)
944
return a_bzrdir.open_branch()
946
def initialize(self, a_bzrdir):
947
assert isinstance(a_bzrdir, RemoteBzrDir)
948
return a_bzrdir.create_branch()
2103
950
def supports_tags(self):
2104
951
# Remote branches might support tags, but we won't know until we
2105
952
# access the real remote branch.
2107
return self._custom_format.supports_tags()
2109
def supports_stacking(self):
2111
return self._custom_format.supports_stacking()
2113
def supports_set_append_revisions_only(self):
2115
return self._custom_format.supports_set_append_revisions_only()
2118
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
956
class RemoteBranch(branch.Branch):
2119
957
"""Branch stored on a server accessed by HPSS RPC.
2121
959
At the moment most operations are mapped down to simple file operations.
2124
962
def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2125
_client=None, format=None, setup_stacking=True, name=None):
2126
964
"""Create a RemoteBranch instance.
2128
966
:param real_branch: An optional local implementation of the branch
2129
967
format, usually accessing the data via the VFS.
2130
968
:param _client: Private parameter for testing.
2131
:param format: A RemoteBranchFormat object, None to create one
2132
automatically. If supplied it should have a network_name already
2134
:param setup_stacking: If True make an RPC call to determine the
2135
stacked (or not) status of the branch. If False assume the branch
2137
:param name: Colocated branch name
2139
970
# We intentionally don't call the parent class's __init__, because it
2140
971
# will try to assign to self.tags, which is a property in this subclass.
2141
972
# And the parent's __init__ doesn't do much anyway.
973
self._revision_id_to_revno_cache = None
974
self._revision_history_cache = None
2142
975
self.bzrdir = remote_bzrdir
2143
976
if _client is not None:
2144
977
self._client = _client
2146
self._client = remote_bzrdir._client
979
self._client = client._SmartClient(self.bzrdir._shared_medium)
2147
980
self.repository = remote_repository
2148
981
if real_branch is not None:
2149
982
self._real_branch = real_branch
2226
1010
Used before calls to self._real_branch.
2228
if self._real_branch is None:
2229
if not vfs.vfs_enabled():
2230
raise AssertionError('smart server vfs must be enabled '
2231
'to use vfs implementation')
1012
if not self._real_branch:
1013
assert vfs.vfs_enabled()
2232
1014
self.bzrdir._ensure_real()
2233
self._real_branch = self.bzrdir._real_bzrdir.open_branch(
2234
ignore_fallbacks=self._real_ignore_fallbacks, name=self._name)
2235
if self.repository._real_repository is None:
2236
# Give the remote repository the matching real repo.
2237
real_repo = self._real_branch.repository
2238
if isinstance(real_repo, RemoteRepository):
2239
real_repo._ensure_real()
2240
real_repo = real_repo._real_repository
2241
self.repository._set_real_repository(real_repo)
2242
# Give the real branch the remote repository to let fast-pathing
1015
self._real_branch = self.bzrdir._real_bzrdir.open_branch()
1016
# Give the remote repository the matching real repo.
1017
real_repo = self._real_branch.repository
1018
if isinstance(real_repo, RemoteRepository):
1019
real_repo._ensure_real()
1020
real_repo = real_repo._real_repository
1021
self.repository._set_real_repository(real_repo)
1022
# Give the branch the remote repository to let fast-pathing happen.
2244
1023
self._real_branch.repository = self.repository
1024
# XXX: deal with _lock_mode == 'w'
2245
1025
if self._lock_mode == 'r':
2246
1026
self._real_branch.lock_read()
2247
elif self._lock_mode == 'w':
2248
self._real_branch.lock_write(token=self._lock_token)
2250
def _translate_error(self, err, **context):
2251
self.repository._translate_error(err, branch=self, **context)
2253
def _clear_cached_state(self):
2254
super(RemoteBranch, self)._clear_cached_state()
2255
if self._real_branch is not None:
2256
self._real_branch._clear_cached_state()
2258
def _clear_cached_state_of_remote_branch_only(self):
2259
"""Like _clear_cached_state, but doesn't clear the cache of
2262
This is useful when falling back to calling a method of
2263
self._real_branch that changes state. In that case the underlying
2264
branch changes, so we need to invalidate this RemoteBranch's cache of
2265
it. However, there's no need to invalidate the _real_branch's cache
2266
too, in fact doing so might harm performance.
2268
super(RemoteBranch, self)._clear_cached_state()
2271
1029
def control_files(self):
2286
1044
self._ensure_real()
2287
1045
return self._real_branch.get_physical_lock_status()
2289
def get_stacked_on_url(self):
2290
"""Get the URL this branch is stacked against.
2292
:raises NotStacked: If the branch is not stacked.
2293
:raises UnstackableBranchFormat: If the branch does not support
2295
:raises UnstackableRepositoryFormat: If the repository does not support
2299
# there may not be a repository yet, so we can't use
2300
# self._translate_error, so we can't use self._call either.
2301
response = self._client.call('Branch.get_stacked_on_url',
2302
self._remote_path())
2303
except errors.ErrorFromSmartServer, err:
2304
# there may not be a repository yet, so we can't call through
2305
# its _translate_error
2306
_translate_error(err, branch=self)
2307
except errors.UnknownSmartMethod, err:
2309
return self._real_branch.get_stacked_on_url()
2310
if response[0] != 'ok':
2311
raise errors.UnexpectedSmartServerResponse(response)
2314
def set_stacked_on_url(self, url):
2315
branch.Branch.set_stacked_on_url(self, url)
2317
self._is_stacked = False
2319
self._is_stacked = True
2321
def _vfs_get_tags_bytes(self):
2323
return self._real_branch._get_tags_bytes()
2325
def _get_tags_bytes(self):
2326
medium = self._client._medium
2327
if medium._is_remote_before((1, 13)):
2328
return self._vfs_get_tags_bytes()
2330
response = self._call('Branch.get_tags_bytes', self._remote_path())
2331
except errors.UnknownSmartMethod:
2332
medium._remember_remote_is_before((1, 13))
2333
return self._vfs_get_tags_bytes()
2336
def _vfs_set_tags_bytes(self, bytes):
2338
return self._real_branch._set_tags_bytes(bytes)
2340
def _set_tags_bytes(self, bytes):
2341
medium = self._client._medium
2342
if medium._is_remote_before((1, 18)):
2343
self._vfs_set_tags_bytes(bytes)
2347
self._remote_path(), self._lock_token, self._repo_lock_token)
2348
response = self._call_with_body_bytes(
2349
'Branch.set_tags_bytes', args, bytes)
2350
except errors.UnknownSmartMethod:
2351
medium._remember_remote_is_before((1, 18))
2352
self._vfs_set_tags_bytes(bytes)
2354
1047
def lock_read(self):
2355
self.repository.lock_read()
2356
1048
if not self._lock_mode:
2357
self._note_lock('r')
2358
1049
self._lock_mode = 'r'
2359
1050
self._lock_count = 1
2360
1051
if self._real_branch is not None:
2369
1060
branch_token = token
2370
1061
repo_token = self.repository.lock_write()
2371
1062
self.repository.unlock()
2372
err_context = {'token': token}
2373
response = self._call(
2374
'Branch.lock_write', self._remote_path(), branch_token,
2375
repo_token or '', **err_context)
2376
if response[0] != 'ok':
1063
path = self.bzrdir._path_for_remote_call(self._client)
1064
response = self._client.call('Branch.lock_write', path, branch_token,
1066
if response[0] == 'ok':
1067
ok, branch_token, repo_token = response
1068
return branch_token, repo_token
1069
elif response[0] == 'LockContention':
1070
raise errors.LockContention('(remote lock)')
1071
elif response[0] == 'TokenMismatch':
1072
raise errors.TokenMismatch(token, '(remote token)')
1073
elif response[0] == 'UnlockableTransport':
1074
raise errors.UnlockableTransport(self.bzrdir.root_transport)
1075
elif response[0] == 'ReadOnlyError':
1076
raise errors.ReadOnlyError(self)
1077
elif response[0] == 'LockFailed':
1078
raise errors.LockFailed(response[1], response[2])
2377
1080
raise errors.UnexpectedSmartServerResponse(response)
2378
ok, branch_token, repo_token = response
2379
return branch_token, repo_token
2381
1082
def lock_write(self, token=None):
2382
1083
if not self._lock_mode:
2383
self._note_lock('w')
2384
# Lock the branch and repo in one remote call.
2385
1084
remote_tokens = self._remote_lock_write(token)
2386
1085
self._lock_token, self._repo_lock_token = remote_tokens
2387
if not self._lock_token:
2388
raise SmartProtocolError('Remote server did not return a token!')
2389
# Tell the self.repository object that it is locked.
2390
self.repository.lock_write(
2391
self._repo_lock_token, _skip_rpc=True)
1086
assert self._lock_token, 'Remote server did not return a token!'
1087
# TODO: We really, really, really don't want to call _ensure_real
1088
# here, but it's the easiest way to ensure coherency between the
1089
# state of the RemoteBranch and RemoteRepository objects and the
1090
# physical locks. If we don't materialise the real objects here,
1091
# then getting everything in the right state later is complex, so
1092
# for now we just do it the lazy way.
1093
# -- Andrew Bennetts, 2007-02-22.
2393
1095
if self._real_branch is not None:
2394
self._real_branch.lock_write(token=self._lock_token)
1096
self._real_branch.repository.lock_write(
1097
token=self._repo_lock_token)
1099
self._real_branch.lock_write(token=self._lock_token)
1101
self._real_branch.repository.unlock()
2395
1102
if token is not None:
2396
1103
self._leave_lock = True
1105
# XXX: this case seems to be unreachable; token cannot be None.
2398
1106
self._leave_lock = False
2399
1107
self._lock_mode = 'w'
2400
1108
self._lock_count = 1
2402
1110
raise errors.ReadOnlyTransaction
2404
1112
if token is not None:
2405
# A token was given to lock_write, and we're relocking, so
2406
# check that the given token actually matches the one we
1113
# A token was given to lock_write, and we're relocking, so check
1114
# that the given token actually matches the one we already have.
2408
1115
if token != self._lock_token:
2409
1116
raise errors.TokenMismatch(token, self._lock_token)
2410
1117
self._lock_count += 1
2411
# Re-lock the repository too.
2412
self.repository.lock_write(self._repo_lock_token)
2413
1118
return self._lock_token or None
2415
1120
def _unlock(self, branch_token, repo_token):
2416
err_context = {'token': str((branch_token, repo_token))}
2417
response = self._call(
2418
'Branch.unlock', self._remote_path(), branch_token,
2419
repo_token or '', **err_context)
1121
path = self.bzrdir._path_for_remote_call(self._client)
1122
response = self._client.call('Branch.unlock', path, branch_token,
2420
1124
if response == ('ok',):
2422
raise errors.UnexpectedSmartServerResponse(response)
1126
elif response[0] == 'TokenMismatch':
1127
raise errors.TokenMismatch(
1128
str((branch_token, repo_token)), '(remote tokens)')
1130
raise errors.UnexpectedSmartServerResponse(response)
2424
@only_raises(errors.LockNotHeld, errors.LockBroken)
2425
1132
def unlock(self):
2427
self._lock_count -= 1
2428
if not self._lock_count:
2429
self._clear_cached_state()
2430
mode = self._lock_mode
2431
self._lock_mode = None
2432
if self._real_branch is not None:
2433
if (not self._leave_lock and mode == 'w' and
2434
self._repo_lock_token):
2435
# If this RemoteBranch will remove the physical lock
2436
# for the repository, make sure the _real_branch
2437
# doesn't do it first. (Because the _real_branch's
2438
# repository is set to be the RemoteRepository.)
2439
self._real_branch.repository.leave_lock_in_place()
2440
self._real_branch.unlock()
2442
# Only write-locked branched need to make a remote method
2443
# call to perform the unlock.
2445
if not self._lock_token:
2446
raise AssertionError('Locked, but no token!')
2447
branch_token = self._lock_token
2448
repo_token = self._repo_lock_token
2449
self._lock_token = None
2450
self._repo_lock_token = None
2451
if not self._leave_lock:
2452
self._unlock(branch_token, repo_token)
2454
self.repository.unlock()
1133
self._lock_count -= 1
1134
if not self._lock_count:
1135
self._clear_cached_state()
1136
mode = self._lock_mode
1137
self._lock_mode = None
1138
if self._real_branch is not None:
1139
if (not self._leave_lock and mode == 'w' and
1140
self._repo_lock_token):
1141
# If this RemoteBranch will remove the physical lock for the
1142
# repository, make sure the _real_branch doesn't do it
1143
# first. (Because the _real_branch's repository is set to
1144
# be the RemoteRepository.)
1145
self._real_branch.repository.leave_lock_in_place()
1146
self._real_branch.unlock()
1148
# Only write-locked branched need to make a remote method call
1149
# to perfom the unlock.
1151
assert self._lock_token, 'Locked, but no token!'
1152
branch_token = self._lock_token
1153
repo_token = self._repo_lock_token
1154
self._lock_token = None
1155
self._repo_lock_token = None
1156
if not self._leave_lock:
1157
self._unlock(branch_token, repo_token)
2456
1159
def break_lock(self):
2457
1160
self._ensure_real()
2467
1170
raise NotImplementedError(self.dont_leave_lock_in_place)
2468
1171
self._leave_lock = False
2471
def get_rev_id(self, revno, history=None):
2473
return _mod_revision.NULL_REVISION
2474
last_revision_info = self.last_revision_info()
2475
ok, result = self.repository.get_rev_id_for_revno(
2476
revno, last_revision_info)
2479
missing_parent = result[1]
2480
# Either the revision named by the server is missing, or its parent
2481
# is. Call get_parent_map to determine which, so that we report a
2483
parent_map = self.repository.get_parent_map([missing_parent])
2484
if missing_parent in parent_map:
2485
missing_parent = parent_map[missing_parent]
2486
raise errors.RevisionNotPresent(missing_parent, self.repository)
2488
def _last_revision_info(self):
2489
response = self._call('Branch.last_revision_info', self._remote_path())
2490
if response[0] != 'ok':
2491
raise SmartProtocolError('unexpected response code %s' % (response,))
1173
def last_revision_info(self):
1174
"""See Branch.last_revision_info()."""
1175
path = self.bzrdir._path_for_remote_call(self._client)
1176
response = self._client.call('Branch.last_revision_info', path)
1177
assert response[0] == 'ok', 'unexpected response code %s' % (response,)
2492
1178
revno = int(response[1])
2493
1179
last_revision = response[2]
2494
1180
return (revno, last_revision)
2496
1182
def _gen_revision_history(self):
2497
1183
"""See Branch._gen_revision_history()."""
2498
if self._is_stacked:
2500
return self._real_branch._gen_revision_history()
2501
response_tuple, response_handler = self._call_expecting_body(
2502
'Branch.revision_history', self._remote_path())
2503
if response_tuple[0] != 'ok':
2504
raise errors.UnexpectedSmartServerResponse(response_tuple)
2505
result = response_handler.read_body_bytes().split('\x00')
1184
path = self.bzrdir._path_for_remote_call(self._client)
1185
response = self._client.call_expecting_body(
1186
'Branch.revision_history', path)
1187
assert response[0][0] == 'ok', ('unexpected response code %s'
1189
result = response[1].read_body_bytes().split('\x00')
2506
1190
if result == ['']:
2510
def _remote_path(self):
2511
return self.bzrdir._path_for_remote_call(self._client)
2513
def _set_last_revision_descendant(self, revision_id, other_branch,
2514
allow_diverged=False, allow_overwrite_descendant=False):
2515
# This performs additional work to meet the hook contract; while its
2516
# undesirable, we have to synthesise the revno to call the hook, and
2517
# not calling the hook is worse as it means changes can't be prevented.
2518
# Having calculated this though, we can't just call into
2519
# set_last_revision_info as a simple call, because there is a set_rh
2520
# hook that some folk may still be using.
2521
old_revno, old_revid = self.last_revision_info()
2522
history = self._lefthand_history(revision_id)
2523
self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2524
err_context = {'other_branch': other_branch}
2525
response = self._call('Branch.set_last_revision_ex',
2526
self._remote_path(), self._lock_token, self._repo_lock_token,
2527
revision_id, int(allow_diverged), int(allow_overwrite_descendant),
2529
self._clear_cached_state()
2530
if len(response) != 3 and response[0] != 'ok':
2531
raise errors.UnexpectedSmartServerResponse(response)
2532
new_revno, new_revision_id = response[1:]
2533
self._last_revision_info_cache = new_revno, new_revision_id
2534
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2535
if self._real_branch is not None:
2536
cache = new_revno, new_revision_id
2537
self._real_branch._last_revision_info_cache = cache
2539
def _set_last_revision(self, revision_id):
2540
old_revno, old_revid = self.last_revision_info()
2541
# This performs additional work to meet the hook contract; while its
2542
# undesirable, we have to synthesise the revno to call the hook, and
2543
# not calling the hook is worse as it means changes can't be prevented.
2544
# Having calculated this though, we can't just call into
2545
# set_last_revision_info as a simple call, because there is a set_rh
2546
# hook that some folk may still be using.
2547
history = self._lefthand_history(revision_id)
2548
self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2549
self._clear_cached_state()
2550
response = self._call('Branch.set_last_revision',
2551
self._remote_path(), self._lock_token, self._repo_lock_token,
2553
if response != ('ok',):
2554
raise errors.UnexpectedSmartServerResponse(response)
2555
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2557
1194
@needs_write_lock
2558
1195
def set_revision_history(self, rev_history):
2559
1196
# Send just the tip revision of the history; the server will generate
2560
1197
# the full history from that. If the revision doesn't exist in this
2561
1198
# branch, NoSuchRevision will be raised.
1199
path = self.bzrdir._path_for_remote_call(self._client)
2562
1200
if rev_history == []:
2563
1201
rev_id = 'null:'
2565
1203
rev_id = rev_history[-1]
2566
self._set_last_revision(rev_id)
2567
for hook in branch.Branch.hooks['set_rh']:
2568
hook(self, rev_history)
1204
self._clear_cached_state()
1205
response = self._client.call('Branch.set_last_revision',
1206
path, self._lock_token, self._repo_lock_token, rev_id)
1207
if response[0] == 'NoSuchRevision':
1208
raise NoSuchRevision(self, rev_id)
1210
assert response == ('ok',), (
1211
'unexpected response code %r' % (response,))
2569
1212
self._cache_revision_history(rev_history)
2571
def _get_parent_location(self):
2572
medium = self._client._medium
2573
if medium._is_remote_before((1, 13)):
2574
return self._vfs_get_parent_location()
2576
response = self._call('Branch.get_parent', self._remote_path())
2577
except errors.UnknownSmartMethod:
2578
medium._remember_remote_is_before((1, 13))
2579
return self._vfs_get_parent_location()
2580
if len(response) != 1:
2581
raise errors.UnexpectedSmartServerResponse(response)
2582
parent_location = response[0]
2583
if parent_location == '':
2585
return parent_location
2587
def _vfs_get_parent_location(self):
2589
return self._real_branch._get_parent_location()
2591
def _set_parent_location(self, url):
2592
medium = self._client._medium
2593
if medium._is_remote_before((1, 15)):
2594
return self._vfs_set_parent_location(url)
2596
call_url = url or ''
2597
if type(call_url) is not str:
2598
raise AssertionError('url must be a str or None (%s)' % url)
2599
response = self._call('Branch.set_parent_location',
2600
self._remote_path(), self._lock_token, self._repo_lock_token,
2602
except errors.UnknownSmartMethod:
2603
medium._remember_remote_is_before((1, 15))
2604
return self._vfs_set_parent_location(url)
2606
raise errors.UnexpectedSmartServerResponse(response)
2608
def _vfs_set_parent_location(self, url):
2610
return self._real_branch._set_parent_location(url)
1214
def get_parent(self):
1216
return self._real_branch.get_parent()
1218
def set_parent(self, url):
1220
return self._real_branch.set_parent(url)
1222
def get_config(self):
1223
return RemoteBranchConfig(self)
1225
def sprout(self, to_bzrdir, revision_id=None):
1226
# Like Branch.sprout, except that it sprouts a branch in the default
1227
# format, because RemoteBranches can't be created at arbitrary URLs.
1228
# XXX: if to_bzrdir is a RemoteBranch, this should perhaps do
1229
# to_bzrdir.create_branch...
1230
result = branch.BranchFormat.get_default_format().initialize(to_bzrdir)
1231
self.copy_content_into(result, revision_id=revision_id)
1232
result.set_parent(self.bzrdir.root_transport.base)
2612
1235
@needs_write_lock
2613
1236
def pull(self, source, overwrite=False, stop_revision=None,
2615
self._clear_cached_state_of_remote_branch_only()
1238
# FIXME: This asks the real branch to run the hooks, which means
1239
# they're called with the wrong target branch parameter.
1240
# The test suite specifically allows this at present but it should be
1241
# fixed. It should get a _override_hook_target branch,
1242
# as push does. -- mbp 20070405
2616
1243
self._ensure_real()
2617
return self._real_branch.pull(
1244
self._real_branch.pull(
2618
1245
source, overwrite=overwrite, stop_revision=stop_revision,
2619
_override_hook_target=self, **kwargs)
2621
1248
@needs_read_lock
2622
1249
def push(self, target, overwrite=False, stop_revision=None):
2628
1255
def is_locked(self):
2629
1256
return self._lock_count >= 1
2632
def revision_id_to_revno(self, revision_id):
2634
return self._real_branch.revision_id_to_revno(revision_id)
2637
1258
def set_last_revision_info(self, revno, revision_id):
2638
# XXX: These should be returned by the set_last_revision_info verb
2639
old_revno, old_revid = self.last_revision_info()
2640
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2641
revision_id = ensure_null(revision_id)
2643
response = self._call('Branch.set_last_revision_info',
2644
self._remote_path(), self._lock_token, self._repo_lock_token,
2645
str(revno), revision_id)
2646
except errors.UnknownSmartMethod:
2648
self._clear_cached_state_of_remote_branch_only()
2649
self._real_branch.set_last_revision_info(revno, revision_id)
2650
self._last_revision_info_cache = revno, revision_id
2652
if response == ('ok',):
2653
self._clear_cached_state()
2654
self._last_revision_info_cache = revno, revision_id
2655
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2656
# Update the _real_branch's cache too.
2657
if self._real_branch is not None:
2658
cache = self._last_revision_info_cache
2659
self._real_branch._last_revision_info_cache = cache
2661
raise errors.UnexpectedSmartServerResponse(response)
1260
self._clear_cached_state()
1261
return self._real_branch.set_last_revision_info(revno, revision_id)
2664
1263
def generate_revision_history(self, revision_id, last_rev=None,
2665
1264
other_branch=None):
2666
medium = self._client._medium
2667
if not medium._is_remote_before((1, 6)):
2668
# Use a smart method for 1.6 and above servers
2670
self._set_last_revision_descendant(revision_id, other_branch,
2671
allow_diverged=True, allow_overwrite_descendant=True)
2673
except errors.UnknownSmartMethod:
2674
medium._remember_remote_is_before((1, 6))
2675
self._clear_cached_state_of_remote_branch_only()
2676
self.set_revision_history(self._lefthand_history(revision_id,
2677
last_rev=last_rev,other_branch=other_branch))
1266
return self._real_branch.generate_revision_history(
1267
revision_id, last_rev=last_rev, other_branch=other_branch)
1272
return self._real_branch.tags
2679
1274
def set_push_location(self, location):
2680
1275
self._ensure_real()
2681
1276
return self._real_branch.set_push_location(location)
2684
class RemoteConfig(object):
2685
"""A Config that reads and writes from smart verbs.
2687
It is a low-level object that considers config data to be name/value pairs
2688
that may be associated with a section. Assigning meaning to the these
2689
values is done at higher levels like bzrlib.config.TreeConfig.
2692
def get_option(self, name, section=None, default=None):
2693
"""Return the value associated with a named option.
2695
:param name: The name of the value
2696
:param section: The section the option is in (if any)
2697
:param default: The value to return if the value is not set
2698
:return: The value or default value
2701
configobj = self._get_configobj()
2703
section_obj = configobj
2706
section_obj = configobj[section]
2709
return section_obj.get(name, default)
2710
except errors.UnknownSmartMethod:
2711
return self._vfs_get_option(name, section, default)
2713
def _response_to_configobj(self, response):
2714
if len(response[0]) and response[0][0] != 'ok':
2715
raise errors.UnexpectedSmartServerResponse(response)
2716
lines = response[1].read_body_bytes().splitlines()
2717
return config.ConfigObj(lines, encoding='utf-8')
2720
class RemoteBranchConfig(RemoteConfig):
2721
"""A RemoteConfig for Branches."""
2723
def __init__(self, branch):
2724
self._branch = branch
2726
def _get_configobj(self):
2727
path = self._branch._remote_path()
2728
response = self._branch._client.call_expecting_body(
2729
'Branch.get_config_file', path)
2730
return self._response_to_configobj(response)
2732
def set_option(self, value, name, section=None):
2733
"""Set the value associated with a named option.
2735
:param value: The value to set
2736
:param name: The name of the value to set
2737
:param section: The section the option is in (if any)
2739
medium = self._branch._client._medium
2740
if medium._is_remote_before((1, 14)):
2741
return self._vfs_set_option(value, name, section)
2743
path = self._branch._remote_path()
2744
response = self._branch._client.call('Branch.set_config_option',
2745
path, self._branch._lock_token, self._branch._repo_lock_token,
2746
value.encode('utf8'), name, section or '')
2747
except errors.UnknownSmartMethod:
2748
medium._remember_remote_is_before((1, 14))
2749
return self._vfs_set_option(value, name, section)
2751
raise errors.UnexpectedSmartServerResponse(response)
2753
def _real_object(self):
2754
self._branch._ensure_real()
2755
return self._branch._real_branch
2757
def _vfs_set_option(self, value, name, section=None):
2758
return self._real_object()._get_config().set_option(
2759
value, name, section)
2762
class RemoteBzrDirConfig(RemoteConfig):
2763
"""A RemoteConfig for BzrDirs."""
2765
def __init__(self, bzrdir):
2766
self._bzrdir = bzrdir
2768
def _get_configobj(self):
2769
medium = self._bzrdir._client._medium
2770
verb = 'BzrDir.get_config_file'
2771
if medium._is_remote_before((1, 15)):
2772
raise errors.UnknownSmartMethod(verb)
2773
path = self._bzrdir._path_for_remote_call(self._bzrdir._client)
2774
response = self._bzrdir._call_expecting_body(
2776
return self._response_to_configobj(response)
2778
def _vfs_get_option(self, name, section, default):
2779
return self._real_object()._get_config().get_option(
2780
name, section, default)
2782
def set_option(self, value, name, section=None):
2783
"""Set the value associated with a named option.
2785
:param value: The value to set
2786
:param name: The name of the value to set
2787
:param section: The section the option is in (if any)
2789
return self._real_object()._get_config().set_option(
2790
value, name, section)
2792
def _real_object(self):
2793
self._bzrdir._ensure_real()
2794
return self._bzrdir._real_bzrdir
1278
def update_revisions(self, other, stop_revision=None):
1280
return self._real_branch.update_revisions(
1281
other, stop_revision=stop_revision)
1284
class RemoteBranchConfig(BranchConfig):
1287
self.branch._ensure_real()
1288
return self.branch._real_branch.get_config().username()
1290
def _get_branch_data_config(self):
1291
self.branch._ensure_real()
1292
if self._branch_data_config is None:
1293
self._branch_data_config = TreeConfig(self.branch._real_branch)
1294
return self._branch_data_config
2798
1297
def _extract_tar(tar, to_dir):
2803
1302
for tarinfo in tar:
2804
1303
tar.extract(tarinfo, to_dir)
2807
def _translate_error(err, **context):
2808
"""Translate an ErrorFromSmartServer into a more useful error.
2810
Possible context keys:
2818
If the error from the server doesn't match a known pattern, then
2819
UnknownErrorFromSmartServer is raised.
2823
return context[name]
2824
except KeyError, key_err:
2825
mutter('Missing key %r in context %r', key_err.args[0], context)
2828
"""Get the path from the context if present, otherwise use first error
2832
return context['path']
2833
except KeyError, key_err:
2835
return err.error_args[0]
2836
except IndexError, idx_err:
2838
'Missing key %r in context %r', key_err.args[0], context)
2841
if err.error_verb == 'IncompatibleRepositories':
2842
raise errors.IncompatibleRepositories(err.error_args[0],
2843
err.error_args[1], err.error_args[2])
2844
elif err.error_verb == 'NoSuchRevision':
2845
raise NoSuchRevision(find('branch'), err.error_args[0])
2846
elif err.error_verb == 'nosuchrevision':
2847
raise NoSuchRevision(find('repository'), err.error_args[0])
2848
elif err.error_verb == 'nobranch':
2849
if len(err.error_args) >= 1:
2850
extra = err.error_args[0]
2853
raise errors.NotBranchError(path=find('bzrdir').root_transport.base,
2855
elif err.error_verb == 'norepository':
2856
raise errors.NoRepositoryPresent(find('bzrdir'))
2857
elif err.error_verb == 'LockContention':
2858
raise errors.LockContention('(remote lock)')
2859
elif err.error_verb == 'UnlockableTransport':
2860
raise errors.UnlockableTransport(find('bzrdir').root_transport)
2861
elif err.error_verb == 'LockFailed':
2862
raise errors.LockFailed(err.error_args[0], err.error_args[1])
2863
elif err.error_verb == 'TokenMismatch':
2864
raise errors.TokenMismatch(find('token'), '(remote token)')
2865
elif err.error_verb == 'Diverged':
2866
raise errors.DivergedBranches(find('branch'), find('other_branch'))
2867
elif err.error_verb == 'TipChangeRejected':
2868
raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
2869
elif err.error_verb == 'UnstackableBranchFormat':
2870
raise errors.UnstackableBranchFormat(*err.error_args)
2871
elif err.error_verb == 'UnstackableRepositoryFormat':
2872
raise errors.UnstackableRepositoryFormat(*err.error_args)
2873
elif err.error_verb == 'NotStacked':
2874
raise errors.NotStacked(branch=find('branch'))
2875
elif err.error_verb == 'PermissionDenied':
2877
if len(err.error_args) >= 2:
2878
extra = err.error_args[1]
2881
raise errors.PermissionDenied(path, extra=extra)
2882
elif err.error_verb == 'ReadError':
2884
raise errors.ReadError(path)
2885
elif err.error_verb == 'NoSuchFile':
2887
raise errors.NoSuchFile(path)
2888
elif err.error_verb == 'FileExists':
2889
raise errors.FileExists(err.error_args[0])
2890
elif err.error_verb == 'DirectoryNotEmpty':
2891
raise errors.DirectoryNotEmpty(err.error_args[0])
2892
elif err.error_verb == 'ShortReadvError':
2893
args = err.error_args
2894
raise errors.ShortReadvError(
2895
args[0], int(args[1]), int(args[2]), int(args[3]))
2896
elif err.error_verb in ('UnicodeEncodeError', 'UnicodeDecodeError'):
2897
encoding = str(err.error_args[0]) # encoding must always be a string
2898
val = err.error_args[1]
2899
start = int(err.error_args[2])
2900
end = int(err.error_args[3])
2901
reason = str(err.error_args[4]) # reason must always be a string
2902
if val.startswith('u:'):
2903
val = val[2:].decode('utf-8')
2904
elif val.startswith('s:'):
2905
val = val[2:].decode('base64')
2906
if err.error_verb == 'UnicodeDecodeError':
2907
raise UnicodeDecodeError(encoding, val, start, end, reason)
2908
elif err.error_verb == 'UnicodeEncodeError':
2909
raise UnicodeEncodeError(encoding, val, start, end, reason)
2910
elif err.error_verb == 'ReadOnlyError':
2911
raise errors.TransportNotPossible('readonly transport')
2912
raise errors.UnknownErrorFromSmartServer(err)
added
removed
bzrlib/remote.py
