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 (
30
repository as _mod_repository,
32
revision as _mod_revision,
36
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
29
from bzrlib.branch import Branch, BranchReferenceFormat
37
30
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
38
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
39
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 (
43
from bzrlib.lockable_files import LockableFiles
44
from bzrlib.smart import client, vfs, repository as smart_repo
45
from bzrlib.revision import ensure_null, NULL_REVISION
46
from bzrlib.repository import RepositoryWriteLockResult
47
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]
41
from bzrlib.trace import note
90
43
# Note: RemoteBzrDirFormat is in bzrdir.py
92
class RemoteBzrDir(BzrDir, _RpcHelper):
45
class RemoteBzrDir(BzrDir):
93
46
"""Control directory on a remote server, accessed via bzr:// or similar."""
95
def __init__(self, transport, format, _client=None, _force_probe=False):
48
def __init__(self, transport, _client=None):
96
49
"""Construct a RemoteBzrDir.
98
51
:param _client: Private parameter for testing. Disables probing and the
99
52
use of a real bzrdir.
101
BzrDir.__init__(self, transport, format)
54
BzrDir.__init__(self, transport, RemoteBzrDirFormat())
102
55
# this object holds a delegated bzrdir that uses file-level operations
103
56
# to talk to the other side
104
57
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
59
if _client is None:
111
medium = transport.get_smart_medium()
112
self._client = client._SmartClient(medium)
60
self._shared_medium = transport.get_shared_medium()
61
self._client = client._SmartClient(self._shared_medium)
114
63
self._client = _client
121
return '%s(%r)' % (self.__class__.__name__, self._client)
123
def _probe_bzrdir(self):
124
medium = self._client._medium
64
self._shared_medium = None
125
67
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)
68
response = self._client.call('BzrDir.open', path)
152
69
if response not in [('yes',), ('no',)]:
153
70
raise errors.UnexpectedSmartServerResponse(response)
154
71
if response == ('no',):
155
raise errors.NotBranchError(path=self.root_transport.base)
72
raise errors.NotBranchError(path=transport.base)
157
74
def _ensure_real(self):
158
75
"""Ensure that there is a _real_bzrdir set.
160
77
Used before calls to self._real_bzrdir.
162
79
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
80
self._real_bzrdir = BzrDir.open_from_transport(
168
81
self.root_transport, _server_formats=False)
169
self._format._network_name = \
170
self._real_bzrdir._format.network_name()
172
def _translate_error(self, err, **context):
173
_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
83
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()
243
def destroy_repository(self):
244
"""See BzrDir.destroy_repository"""
246
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
267
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):
268
94
"""See BzrDir.destroy_branch"""
269
95
self._ensure_real()
270
self._real_bzrdir.destroy_branch(name=name)
271
self._next_open_branch_result = None
96
self._real_bzrdir.destroy_branch()
273
98
def create_workingtree(self, revision_id=None, from_branch=None):
274
99
raise errors.NotLocalUrl(self.transport.base)
276
def find_branch_format(self, name=None):
101
def find_branch_format(self):
277
102
"""Find the branch 'format' for this bzrdir.
279
104
This might be a synthetic object for e.g. RemoteBranch and SVN.
281
b = self.open_branch(name=name)
106
b = self.open_branch()
284
def get_branch_reference(self, name=None):
109
def get_branch_reference(self):
285
110
"""See BzrDir.get_branch_reference()."""
287
# XXX JRV20100304: Support opening colocated branches
288
raise errors.NoColocatedBranchSupport(self)
289
response = self._get_branch_reference()
290
if response[0] == 'ref':
295
def _get_branch_reference(self):
296
111
path = self._path_for_remote_call(self._client)
297
medium = self._client._medium
299
('BzrDir.open_branchV3', (2, 1)),
300
('BzrDir.open_branchV2', (1, 13)),
301
('BzrDir.open_branch', None),
303
for verb, required_version in candidate_calls:
304
if required_version and medium._is_remote_before(required_version):
307
response = self._call(verb, path)
308
except errors.UnknownSmartMethod:
309
if required_version is None:
311
medium._remember_remote_is_before(required_version)
314
if verb == 'BzrDir.open_branch':
315
if response[0] != 'ok':
316
raise errors.UnexpectedSmartServerResponse(response)
317
if response[1] != '':
318
return ('ref', response[1])
320
return ('branch', '')
321
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)
322
123
raise errors.UnexpectedSmartServerResponse(response)
325
def _get_tree_branch(self, name=None):
326
"""See BzrDir._get_tree_branch()."""
327
return None, self.open_branch(name=name)
329
def open_branch(self, name=None, unsupported=False,
330
ignore_fallbacks=False):
332
raise NotImplementedError('unsupported flag support not implemented yet.')
333
if self._next_open_branch_result is not None:
334
# See create_branch for details.
335
result = self._next_open_branch_result
336
self._next_open_branch_result = None
338
response = self._get_branch_reference()
339
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())
340
132
# a branch reference, use the existing BranchReference logic.
341
133
format = BranchReferenceFormat()
342
return format.open(self, name=name, _found=True,
343
location=response[1], ignore_fallbacks=ignore_fallbacks)
344
branch_format_name = response[1]
345
if not branch_format_name:
346
branch_format_name = None
347
format = RemoteBranchFormat(network_name=branch_format_name)
348
return RemoteBranch(self, self.find_repository(), format=format,
349
setup_stacking=not ignore_fallbacks, name=name)
351
def _open_repo_v1(self, path):
352
verb = 'BzrDir.find_repository'
353
response = self._call(verb, path)
354
if response[0] != 'ok':
355
raise errors.UnexpectedSmartServerResponse(response)
356
# servers that only support the v1 method don't support external
359
repo = self._real_bzrdir.open_repository()
360
response = response + ('no', repo._format.network_name())
361
return response, repo
363
def _open_repo_v2(self, path):
364
verb = 'BzrDir.find_repositoryV2'
365
response = self._call(verb, path)
366
if response[0] != 'ok':
367
raise errors.UnexpectedSmartServerResponse(response)
369
repo = self._real_bzrdir.open_repository()
370
response = response + (repo._format.network_name(),)
371
return response, repo
373
def _open_repo_v3(self, path):
374
verb = 'BzrDir.find_repositoryV3'
375
medium = self._client._medium
376
if medium._is_remote_before((1, 13)):
377
raise errors.UnknownSmartMethod(verb)
379
response = self._call(verb, path)
380
except errors.UnknownSmartMethod:
381
medium._remember_remote_is_before((1, 13))
383
if response[0] != 'ok':
384
raise errors.UnexpectedSmartServerResponse(response)
385
return response, None
134
return format.open(self, _found=True, location=reference_url)
387
136
def open_repository(self):
388
137
path = self._path_for_remote_call(self._client)
390
for probe in [self._open_repo_v3, self._open_repo_v2,
393
response, real_repo = probe(path)
395
except errors.UnknownSmartMethod:
398
raise errors.UnknownSmartMethod('BzrDir.find_repository{3,2,}')
399
if response[0] != 'ok':
400
raise errors.UnexpectedSmartServerResponse(response)
401
if len(response) != 6:
402
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,)
403
144
if response[1] == '':
404
# repo is at this dir.
405
format = response_tuple_to_repo_format(response[2:])
406
# Used to support creating a real format instance when needed.
407
format._creating_bzrdir = self
408
remote_repo = RemoteRepository(self, format)
409
format._creating_repo = remote_repo
410
if real_repo is not None:
411
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)
414
150
raise errors.NoRepositoryPresent(self)
416
def has_workingtree(self):
417
if self._has_working_tree is None:
419
self._has_working_tree = self._real_bzrdir.has_workingtree()
420
return self._has_working_tree
422
152
def open_workingtree(self, recommend_upgrade=True):
423
if self.has_workingtree():
154
if self._real_bzrdir.has_workingtree():
424
155
raise errors.NotLocalUrl(self.root_transport)
426
157
raise errors.NoWorkingTree(self.root_transport.base)
468
192
Instances of this repository are represented by RemoteRepository
471
The RemoteRepositoryFormat is parameterized during construction
195
The RemoteRepositoryFormat is parameterised during construction
472
196
to reflect the capabilities of the real, remote format. Specifically
473
197
the attributes rich_root_data and supports_tree_reference are set
474
198
on a per instance basis, and are not set (and should not be) at
477
:ivar _custom_format: If set, a specific concrete repository format that
478
will be used when initializing a repository with this
479
RemoteRepositoryFormat.
480
:ivar _creating_repo: If set, the repository object that this
481
RemoteRepositoryFormat was created for: it can be called into
482
to obtain data like the network name.
485
_matchingbzrdir = RemoteBzrDirFormat()
488
repository.RepositoryFormat.__init__(self)
489
self._custom_format = None
490
self._network_name = None
491
self._creating_bzrdir = None
492
self._supports_chks = None
493
self._supports_external_lookups = None
494
self._supports_tree_reference = None
495
self._rich_root_data = None
498
return "%s(_network_name=%r)" % (self.__class__.__name__,
502
def fast_deltas(self):
504
return self._custom_format.fast_deltas
507
def rich_root_data(self):
508
if self._rich_root_data is None:
510
self._rich_root_data = self._custom_format.rich_root_data
511
return self._rich_root_data
514
def supports_chks(self):
515
if self._supports_chks is None:
517
self._supports_chks = self._custom_format.supports_chks
518
return self._supports_chks
521
def supports_external_lookups(self):
522
if self._supports_external_lookups is None:
524
self._supports_external_lookups = \
525
self._custom_format.supports_external_lookups
526
return self._supports_external_lookups
529
def supports_tree_reference(self):
530
if self._supports_tree_reference is None:
532
self._supports_tree_reference = \
533
self._custom_format.supports_tree_reference
534
return self._supports_tree_reference
536
def _vfs_initialize(self, a_bzrdir, shared):
537
"""Helper for common code in initialize."""
538
if self._custom_format:
539
# Custom format requested
540
result = self._custom_format.initialize(a_bzrdir, shared=shared)
541
elif self._creating_bzrdir is not None:
542
# Use the format that the repository we were created to back
544
prior_repo = self._creating_bzrdir.open_repository()
545
prior_repo._ensure_real()
546
result = prior_repo._real_repository._format.initialize(
547
a_bzrdir, shared=shared)
549
# assume that a_bzr is a RemoteBzrDir but the smart server didn't
550
# support remote initialization.
551
# We delegate to a real object at this point (as RemoteBzrDir
552
# delegate to the repository format which would lead to infinite
553
# recursion if we just called a_bzrdir.create_repository.
554
a_bzrdir._ensure_real()
555
result = a_bzrdir._real_bzrdir.create_repository(shared=shared)
556
if not isinstance(result, RemoteRepository):
557
return self.open(a_bzrdir)
202
_matchingbzrdir = RemoteBzrDirFormat
561
204
def initialize(self, a_bzrdir, shared=False):
562
# Being asked to create on a non RemoteBzrDir:
563
if not isinstance(a_bzrdir, RemoteBzrDir):
564
return self._vfs_initialize(a_bzrdir, shared)
565
medium = a_bzrdir._client._medium
566
if medium._is_remote_before((1, 13)):
567
return self._vfs_initialize(a_bzrdir, shared)
568
# Creating on a remote bzr dir.
569
# 1) get the network name to use.
570
if self._custom_format:
571
network_name = self._custom_format.network_name()
572
elif self._network_name:
573
network_name = self._network_name
575
# Select the current bzrlib default and ask for that.
576
reference_bzrdir_format = bzrdir.format_registry.get('default')()
577
reference_format = reference_bzrdir_format.repository_format
578
network_name = reference_format.network_name()
579
# 2) try direct creation via RPC
580
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
581
verb = 'BzrDir.create_repository'
587
response = a_bzrdir._call(verb, path, network_name, shared_str)
588
except errors.UnknownSmartMethod:
589
# Fallback - use vfs methods
590
medium._remember_remote_is_before((1, 13))
591
return self._vfs_initialize(a_bzrdir, shared)
593
# Turn the response into a RemoteRepository object.
594
format = response_tuple_to_repo_format(response[1:])
595
# Used to support creating a real format instance when needed.
596
format._creating_bzrdir = a_bzrdir
597
remote_repo = RemoteRepository(a_bzrdir, format)
598
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)
601
209
def open(self, a_bzrdir):
602
if not isinstance(a_bzrdir, RemoteBzrDir):
603
raise AssertionError('%r is not a RemoteBzrDir' % (a_bzrdir,))
210
assert isinstance(a_bzrdir, RemoteBzrDir)
604
211
return a_bzrdir.open_repository()
606
def _ensure_real(self):
607
if self._custom_format is None:
608
self._custom_format = repository.network_format_registry.get(
612
def _fetch_order(self):
614
return self._custom_format._fetch_order
617
def _fetch_uses_deltas(self):
619
return self._custom_format._fetch_uses_deltas
622
def _fetch_reconcile(self):
624
return self._custom_format._fetch_reconcile
626
213
def get_format_description(self):
628
return 'Remote: ' + self._custom_format.get_format_description()
214
return 'bzr remote repository'
630
216
def __eq__(self, other):
631
return self.__class__ is other.__class__
633
def network_name(self):
634
if self._network_name:
635
return self._network_name
636
self._creating_repo._ensure_real()
637
return self._creating_repo._real_repository._format.network_name()
640
def pack_compresses(self):
642
return self._custom_format.pack_compresses
645
def _serializer(self):
647
return self._custom_format._serializer
650
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
651
bzrdir.ControlComponent):
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):
652
230
"""Repository accessed over rpc.
654
232
For the moment most operations are performed using local transport-backed
748
295
self._ensure_real()
749
296
return self._real_repository.commit_write_group()
751
def resume_write_group(self, tokens):
753
return self._real_repository.resume_write_group(tokens)
755
def suspend_write_group(self):
757
return self._real_repository.suspend_write_group()
759
def get_missing_parent_inventories(self, check_for_missing_texts=True):
761
return self._real_repository.get_missing_parent_inventories(
762
check_for_missing_texts=check_for_missing_texts)
764
def _get_rev_id_for_revno_vfs(self, revno, known_pair):
766
return self._real_repository.get_rev_id_for_revno(
769
def get_rev_id_for_revno(self, revno, known_pair):
770
"""See Repository.get_rev_id_for_revno."""
771
path = self.bzrdir._path_for_remote_call(self._client)
773
if self._client._medium._is_remote_before((1, 17)):
774
return self._get_rev_id_for_revno_vfs(revno, known_pair)
775
response = self._call(
776
'Repository.get_rev_id_for_revno', path, revno, known_pair)
777
except errors.UnknownSmartMethod:
778
self._client._medium._remember_remote_is_before((1, 17))
779
return self._get_rev_id_for_revno_vfs(revno, known_pair)
780
if response[0] == 'ok':
781
return True, response[1]
782
elif response[0] == 'history-incomplete':
783
known_pair = response[1:3]
784
for fallback in self._fallback_repositories:
785
found, result = fallback.get_rev_id_for_revno(revno, known_pair)
790
# Not found in any fallbacks
791
return False, known_pair
793
raise errors.UnexpectedSmartServerResponse(response)
795
298
def _ensure_real(self):
796
299
"""Ensure that there is a _real_repository set.
798
301
Used before calls to self._real_repository.
800
Note that _ensure_real causes many roundtrips to the server which are
801
not desirable, and prevents the use of smart one-roundtrip RPC's to
802
perform complex operations (such as accessing parent data, streaming
803
revisions etc). Adding calls to _ensure_real should only be done when
804
bringing up new functionality, adding fallbacks for smart methods that
805
require a fallback path, and never to replace an existing smart method
806
invocation. If in doubt chat to the bzr network team.
808
if self._real_repository is None:
809
if 'hpssvfs' in debug.debug_flags:
811
warning('VFS Repository access triggered\n%s',
812
''.join(traceback.format_stack()))
813
self._unstacked_provider.missing_keys.clear()
303
if not self._real_repository:
814
304
self.bzrdir._ensure_real()
815
self._set_real_repository(
816
self.bzrdir._real_bzrdir.open_repository())
818
def _translate_error(self, err, **context):
819
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())
821
308
def find_text_key_references(self):
822
309
"""Find the text key references within the repository.
843
330
self._ensure_real()
844
331
return self._real_repository._generate_text_key_index()
846
def _get_revision_graph(self, revision_id):
847
"""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()."""
848
335
if revision_id is None:
850
337
elif revision.is_null(revision_id):
853
340
path = self.bzrdir._path_for_remote_call(self._client)
854
response = self._call_expecting_body(
341
assert type(revision_id) is str
342
response = self._client.call_expecting_body(
855
343
'Repository.get_revision_graph', path, revision_id)
856
response_tuple, response_handler = response
857
if response_tuple[0] != 'ok':
858
raise errors.UnexpectedSmartServerResponse(response_tuple)
859
coded = response_handler.read_body_bytes()
861
# no revisions in this repository!
863
lines = coded.split('\n')
866
d = tuple(line.split())
867
revision_graph[d[0]] = d[1:]
869
return revision_graph
872
"""See Repository._get_sink()."""
873
return RemoteStreamSink(self)
875
def _get_source(self, to_format):
876
"""Return a source for streaming from this repository."""
877
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)
880
363
def has_revision(self, revision_id):
881
"""True if this repository has a copy of the revision."""
882
# Copy of bzrlib.repository.Repository.has_revision
883
return revision_id in self.has_revisions((revision_id,))
886
def has_revisions(self, revision_ids):
887
"""Probe to find out the presence of multiple revisions.
889
:param revision_ids: An iterable of revision_ids.
890
:return: A set of the revision_ids that were present.
892
# Copy of bzrlib.repository.Repository.has_revisions
893
parent_map = self.get_parent_map(revision_ids)
894
result = set(parent_map)
895
if _mod_revision.NULL_REVISION in revision_ids:
896
result.add(_mod_revision.NULL_REVISION)
899
def _has_same_fallbacks(self, other_repo):
900
"""Returns true if the repositories have the same fallbacks."""
901
# XXX: copied from Repository; it should be unified into a base class
902
# <https://bugs.launchpad.net/bzr/+bug/401622>
903
my_fb = self._fallback_repositories
904
other_fb = other_repo._fallback_repositories
905
if len(my_fb) != len(other_fb):
907
for f, g in zip(my_fb, other_fb):
908
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'
912
373
def has_same_location(self, other):
913
# TODO: Move to RepositoryBase and unify with the regular Repository
914
# one; unfortunately the tests rely on slightly different behaviour at
915
# present -- mbp 20090710
916
return (self.__class__ is other.__class__ and
374
return (self.__class__ == other.__class__ and
917
375
self.bzrdir.transport.base == other.bzrdir.transport.base)
919
377
def get_graph(self, other_repository=None):
920
378
"""Return the graph for this repository format"""
921
parents_provider = self._make_parents_provider(other_repository)
922
return graph.Graph(parents_provider)
925
def get_known_graph_ancestry(self, revision_ids):
926
"""Return the known graph for a set of revision ids and their ancestors.
928
st = static_tuple.StaticTuple
929
revision_keys = [st(r_id).intern() for r_id in revision_ids]
930
known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
931
return graph.GraphThunkIdsToKeys(known_graph)
380
return self._real_repository.get_graph(other_repository)
933
382
def gather_stats(self, revid=None, committers=None):
934
383
"""See Repository.gather_stats()."""
987
430
def is_shared(self):
988
431
"""See Repository.is_shared()."""
989
432
path = self.bzrdir._path_for_remote_call(self._client)
990
response = self._call('Repository.is_shared', path)
991
if response[0] not in ('yes', 'no'):
992
raise SmartProtocolError('unexpected response code %s' % (response,))
433
response = self._client.call('Repository.is_shared', path)
434
assert response[0] in ('yes', 'no'), 'unexpected response code %s' % (response,)
993
435
return response[0] == 'yes'
995
437
def is_write_locked(self):
996
438
return self._lock_mode == 'w'
998
def _warn_if_deprecated(self, branch=None):
999
# If we have a real repository, the check will be done there, if we
1000
# don't the check will be done remotely.
1003
440
def lock_read(self):
1004
"""Lock the repository for read operations.
1006
:return: A bzrlib.lock.LogicalLockResult.
1008
441
# wrong eventually - want a local lock cache context
1009
442
if not self._lock_mode:
1010
self._note_lock('r')
1011
443
self._lock_mode = 'r'
1012
444
self._lock_count = 1
1013
self._unstacked_provider.enable_cache(cache_misses=True)
1014
445
if self._real_repository is not None:
1015
446
self._real_repository.lock_read()
1016
for repo in self._fallback_repositories:
1019
448
self._lock_count += 1
1020
return lock.LogicalLockResult(self.unlock)
1022
450
def _remote_lock_write(self, token):
1023
451
path = self.bzrdir._path_for_remote_call(self._client)
1024
452
if token is None:
1026
err_context = {'token': token}
1027
response = self._call('Repository.lock_write', path, token,
454
response = self._client.call('Repository.lock_write', path, token)
1029
455
if response[0] == 'ok':
1030
456
ok, token = response
458
elif response[0] == 'LockContention':
459
raise errors.LockContention('(remote lock)')
460
elif response[0] == 'UnlockableTransport':
461
raise errors.UnlockableTransport(self.bzrdir.root_transport)
462
elif response[0] == 'LockFailed':
463
raise errors.LockFailed(response[1], response[2])
1033
465
raise errors.UnexpectedSmartServerResponse(response)
1035
def lock_write(self, token=None, _skip_rpc=False):
467
def lock_write(self, token=None):
1036
468
if not self._lock_mode:
1037
self._note_lock('w')
1039
if self._lock_token is not None:
1040
if token != self._lock_token:
1041
raise errors.TokenMismatch(token, self._lock_token)
1042
self._lock_token = token
1044
self._lock_token = self._remote_lock_write(token)
469
self._lock_token = self._remote_lock_write(token)
1045
470
# if self._lock_token is None, then this is something like packs or
1046
471
# svn where we don't get to lock the repo, or a weave style repository
1047
472
# where we cannot lock it over the wire and attempts to do so will
1227
610
# FIXME: It ought to be possible to call this without immediately
1228
611
# triggering _ensure_real. For now it's the easiest thing to do.
1229
612
self._ensure_real()
1230
real_repo = self._real_repository
1231
builder = real_repo.get_commit_builder(branch, parents,
613
builder = self._real_repository.get_commit_builder(branch, parents,
1232
614
config, timestamp=timestamp, timezone=timezone,
1233
615
committer=committer, revprops=revprops, revision_id=revision_id)
1236
def add_fallback_repository(self, repository):
1237
"""Add a repository to use for looking up data not held locally.
1239
:param repository: A repository.
1241
if not self._format.supports_external_lookups:
1242
raise errors.UnstackableRepositoryFormat(
1243
self._format.network_name(), self.base)
1244
# We need to accumulate additional repositories here, to pass them in
1247
if self.is_locked():
1248
# We will call fallback.unlock() when we transition to the unlocked
1249
# state, so always add a lock here. If a caller passes us a locked
1250
# repository, they are responsible for unlocking it later.
1251
repository.lock_read()
1252
self._check_fallback_repository(repository)
1253
self._fallback_repositories.append(repository)
1254
# If self._real_repository was parameterised already (e.g. because a
1255
# _real_branch had its get_stacked_on_url method called), then the
1256
# repository to be added may already be in the _real_repositories list.
1257
if self._real_repository is not None:
1258
fallback_locations = [repo.user_url for repo in
1259
self._real_repository._fallback_repositories]
1260
if repository.user_url not in fallback_locations:
1261
self._real_repository.add_fallback_repository(repository)
1263
def _check_fallback_repository(self, repository):
1264
"""Check that this repository can fallback to repository safely.
1266
Raise an error if not.
1268
:param repository: A repository to fallback to.
1270
return _mod_repository.InterRepository._assert_same_model(
1273
619
def add_inventory(self, revid, inv, parents):
1274
620
self._ensure_real()
1275
621
return self._real_repository.add_inventory(revid, inv, parents)
1277
def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1278
parents, basis_inv=None, propagate_caches=False):
1280
return self._real_repository.add_inventory_by_delta(basis_revision_id,
1281
delta, new_revision_id, parents, basis_inv=basis_inv,
1282
propagate_caches=propagate_caches)
1284
624
def add_revision(self, rev_id, rev, inv=None, config=None):
1285
625
self._ensure_real()
1286
626
return self._real_repository.add_revision(
1310
651
return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
1312
653
def make_working_trees(self):
1313
"""See Repository.make_working_trees"""
1315
return self._real_repository.make_working_trees()
1317
def refresh_data(self):
1318
"""Re-read any data needed to synchronise with disk.
1320
This method is intended to be called after another repository instance
1321
(such as one used by a smart server) has inserted data into the
1322
repository. On all repositories this will work outside of write groups.
1323
Some repository formats (pack and newer for bzrlib native formats)
1324
support refresh_data inside write groups. If called inside a write
1325
group on a repository that does not support refreshing in a write group
1326
IsInWriteGroupError will be raised.
1328
if self._real_repository is not None:
1329
self._real_repository.refresh_data()
1331
def revision_ids_to_search_result(self, result_set):
1332
"""Convert a set of revision ids to a graph SearchResult."""
1333
result_parents = set()
1334
for parents in self.get_graph().get_parent_map(
1335
result_set).itervalues():
1336
result_parents.update(parents)
1337
included_keys = result_set.intersection(result_parents)
1338
start_keys = result_set.difference(included_keys)
1339
exclude_keys = result_parents.difference(result_set)
1340
result = graph.SearchResult(start_keys, exclude_keys,
1341
len(result_set), result_set)
1345
def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1346
"""Return the revision ids that other has that this does not.
1348
These are returned in topological order.
1350
revision_id: only return revision ids included by revision_id.
1352
return repository.InterRepository.get(
1353
other, self).search_missing_revision_ids(revision_id, find_ghosts)
1355
def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
1357
# No base implementation to use as RemoteRepository is not a subclass
1358
# of Repository; so this is a copy of Repository.fetch().
1359
if fetch_spec is not None and revision_id is not None:
1360
raise AssertionError(
1361
"fetch_spec and revision_id are mutually exclusive.")
1362
if self.is_in_write_group():
1363
raise errors.InternalBzrError(
1364
"May not fetch while in a write group.")
1365
# fast path same-url fetch operations
1366
if (self.has_same_location(source)
1367
and fetch_spec is None
1368
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):
1369
659
# check that last_revision is in 'from' and then return a
1371
661
if (revision_id is not None and
1372
662
not revision.is_null(revision_id)):
1373
663
self.get_revision(revision_id)
1375
# if there is no specific appropriate InterRepository, this will get
1376
# the InterRepository base class, which raises an
1377
# IncompatibleRepositories when asked to fetch.
1378
inter = repository.InterRepository.get(source, self)
1379
return inter.fetch(revision_id=revision_id, pb=pb,
1380
find_ghosts=find_ghosts, fetch_spec=fetch_spec)
666
return self._real_repository.fetch(
667
source, revision_id=revision_id, pb=pb)
1382
669
def create_bundle(self, target, base, fileobj, format=None):
1383
670
self._ensure_real()
1384
671
self._real_repository.create_bundle(target, base, fileobj, format)
674
def control_weaves(self):
676
return self._real_repository.control_weaves
1386
678
@needs_read_lock
1387
679
def get_ancestry(self, revision_id, topo_sorted=True):
1388
680
self._ensure_real()
1389
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()
1391
688
def fileids_altered_by_revision_ids(self, revision_ids):
1392
689
self._ensure_real()
1393
690
return self._real_repository.fileids_altered_by_revision_ids(revision_ids)
1395
def _get_versioned_file_checker(self, revisions, revision_versions_cache):
692
def get_versioned_file_checker(self, revisions, revision_versions_cache):
1396
693
self._ensure_real()
1397
return self._real_repository._get_versioned_file_checker(
694
return self._real_repository.get_versioned_file_checker(
1398
695
revisions, revision_versions_cache)
1400
697
def iter_files_bytes(self, desired_files):
1401
698
"""See Repository.iter_file_bytes.
1403
700
self._ensure_real()
1404
701
return self._real_repository.iter_files_bytes(desired_files)
1406
def get_parent_map(self, revision_ids):
1407
"""See bzrlib.Graph.get_parent_map()."""
1408
return self._make_parents_provider().get_parent_map(revision_ids)
1410
def _get_parent_map_rpc(self, keys):
1411
"""Helper for get_parent_map that performs the RPC."""
1412
medium = self._client._medium
1413
if medium._is_remote_before((1, 2)):
1414
# We already found out that the server can't understand
1415
# Repository.get_parent_map requests, so just fetch the whole
1418
# Note that this reads the whole graph, when only some keys are
1419
# wanted. On this old server there's no way (?) to get them all
1420
# in one go, and the user probably will have seen a warning about
1421
# the server being old anyhow.
1422
rg = self._get_revision_graph(None)
1423
# There is an API discrepancy between get_parent_map and
1424
# get_revision_graph. Specifically, a "key:()" pair in
1425
# get_revision_graph just means a node has no parents. For
1426
# "get_parent_map" it means the node is a ghost. So fix up the
1427
# graph to correct this.
1428
# https://bugs.launchpad.net/bzr/+bug/214894
1429
# There is one other "bug" which is that ghosts in
1430
# get_revision_graph() are not returned at all. But we won't worry
1431
# about that for now.
1432
for node_id, parent_ids in rg.iteritems():
1433
if parent_ids == ():
1434
rg[node_id] = (NULL_REVISION,)
1435
rg[NULL_REVISION] = ()
1440
raise ValueError('get_parent_map(None) is not valid')
1441
if NULL_REVISION in keys:
1442
keys.discard(NULL_REVISION)
1443
found_parents = {NULL_REVISION:()}
1445
return found_parents
1448
# TODO(Needs analysis): We could assume that the keys being requested
1449
# from get_parent_map are in a breadth first search, so typically they
1450
# will all be depth N from some common parent, and we don't have to
1451
# have the server iterate from the root parent, but rather from the
1452
# keys we're searching; and just tell the server the keyspace we
1453
# already have; but this may be more traffic again.
1455
# Transform self._parents_map into a search request recipe.
1456
# TODO: Manage this incrementally to avoid covering the same path
1457
# repeatedly. (The server will have to on each request, but the less
1458
# work done the better).
1460
# Negative caching notes:
1461
# new server sends missing when a request including the revid
1462
# 'include-missing:' is present in the request.
1463
# missing keys are serialised as missing:X, and we then call
1464
# provider.note_missing(X) for-all X
1465
parents_map = self._unstacked_provider.get_cached_map()
1466
if parents_map is None:
1467
# Repository is not locked, so there's no cache.
1469
# start_set is all the keys in the cache
1470
start_set = set(parents_map)
1471
# result set is all the references to keys in the cache
1472
result_parents = set()
1473
for parents in parents_map.itervalues():
1474
result_parents.update(parents)
1475
stop_keys = result_parents.difference(start_set)
1476
# We don't need to send ghosts back to the server as a position to
1478
stop_keys.difference_update(self._unstacked_provider.missing_keys)
1479
key_count = len(parents_map)
1480
if (NULL_REVISION in result_parents
1481
and NULL_REVISION in self._unstacked_provider.missing_keys):
1482
# If we pruned NULL_REVISION from the stop_keys because it's also
1483
# in our cache of "missing" keys we need to increment our key count
1484
# by 1, because the reconsitituted SearchResult on the server will
1485
# still consider NULL_REVISION to be an included key.
1487
included_keys = start_set.intersection(result_parents)
1488
start_set.difference_update(included_keys)
1489
recipe = ('manual', start_set, stop_keys, key_count)
1490
body = self._serialise_search_recipe(recipe)
1491
path = self.bzrdir._path_for_remote_call(self._client)
1493
if type(key) is not str:
1495
"key %r not a plain string" % (key,))
1496
verb = 'Repository.get_parent_map'
1497
args = (path, 'include-missing:') + tuple(keys)
1499
response = self._call_with_body_bytes_expecting_body(
1501
except errors.UnknownSmartMethod:
1502
# Server does not support this method, so get the whole graph.
1503
# Worse, we have to force a disconnection, because the server now
1504
# doesn't realise it has a body on the wire to consume, so the
1505
# only way to recover is to abandon the connection.
1507
'Server is too old for fast get_parent_map, reconnecting. '
1508
'(Upgrade the server to Bazaar 1.2 to avoid this)')
1510
# To avoid having to disconnect repeatedly, we keep track of the
1511
# fact the server doesn't understand remote methods added in 1.2.
1512
medium._remember_remote_is_before((1, 2))
1513
# Recurse just once and we should use the fallback code.
1514
return self._get_parent_map_rpc(keys)
1515
response_tuple, response_handler = response
1516
if response_tuple[0] not in ['ok']:
1517
response_handler.cancel_read_body()
1518
raise errors.UnexpectedSmartServerResponse(response_tuple)
1519
if response_tuple[0] == 'ok':
1520
coded = bz2.decompress(response_handler.read_body_bytes())
1522
# no revisions found
1524
lines = coded.split('\n')
1527
d = tuple(line.split())
1529
revision_graph[d[0]] = d[1:]
1532
if d[0].startswith('missing:'):
1534
self._unstacked_provider.note_missing_key(revid)
1536
# no parents - so give the Graph result
1538
revision_graph[d[0]] = (NULL_REVISION,)
1539
return revision_graph
1541
703
@needs_read_lock
1542
704
def get_signature_text(self, revision_id):
1543
705
self._ensure_real()
1544
706
return self._real_repository.get_signature_text(revision_id)
1546
708
@needs_read_lock
1547
def _get_inventory_xml(self, revision_id):
1549
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)
1551
723
def reconcile(self, other=None, thorough=False):
1552
724
self._ensure_real()
1553
725
return self._real_repository.reconcile(other=other, thorough=thorough)
1555
727
def all_revision_ids(self):
1556
728
self._ensure_real()
1557
729
return self._real_repository.all_revision_ids()
1560
def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1562
return self._real_repository.get_deltas_for_revisions(revisions,
1563
specific_fileids=specific_fileids)
1566
def get_revision_delta(self, revision_id, specific_fileids=None):
1568
return self._real_repository.get_revision_delta(revision_id,
1569
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)
1571
741
@needs_read_lock
1572
742
def revision_trees(self, revision_ids):
1728
880
self._ensure_real()
1729
881
return self._real_repository.revision_graph_can_have_wrong_parents()
1731
def _find_inconsistent_revision_parents(self, revisions_iterator=None):
883
def _find_inconsistent_revision_parents(self):
1732
884
self._ensure_real()
1733
return self._real_repository._find_inconsistent_revision_parents(
885
return self._real_repository._find_inconsistent_revision_parents()
1736
887
def _check_for_inconsistent_revision_parents(self):
1737
888
self._ensure_real()
1738
889
return self._real_repository._check_for_inconsistent_revision_parents()
1740
def _make_parents_provider(self, other=None):
1741
providers = [self._unstacked_provider]
1742
if other is not None:
1743
providers.insert(0, other)
1744
providers.extend(r._make_parents_provider() for r in
1745
self._fallback_repositories)
1746
return graph.StackedParentsProvider(providers)
1748
def _serialise_search_recipe(self, recipe):
1749
"""Serialise a graph search recipe.
1751
:param recipe: A search recipe (start, stop, count).
1752
:return: Serialised bytes.
1754
start_keys = ' '.join(recipe[1])
1755
stop_keys = ' '.join(recipe[2])
1756
count = str(recipe[3])
1757
return '\n'.join((start_keys, stop_keys, count))
1759
def _serialise_search_result(self, search_result):
1760
if isinstance(search_result, graph.PendingAncestryResult):
1761
parts = ['ancestry-of']
1762
parts.extend(search_result.heads)
1764
recipe = search_result.get_recipe()
1765
parts = [recipe[0], self._serialise_search_recipe(recipe)]
1766
return '\n'.join(parts)
1769
path = self.bzrdir._path_for_remote_call(self._client)
1771
response = self._call('PackRepository.autopack', path)
1772
except errors.UnknownSmartMethod:
1774
self._real_repository._pack_collection.autopack()
1777
if response[0] != 'ok':
1778
raise errors.UnexpectedSmartServerResponse(response)
1781
class RemoteStreamSink(repository.StreamSink):
1783
def _insert_real(self, stream, src_format, resume_tokens):
1784
self.target_repo._ensure_real()
1785
sink = self.target_repo._real_repository._get_sink()
1786
result = sink.insert_stream(stream, src_format, resume_tokens)
1788
self.target_repo.autopack()
1791
def insert_stream(self, stream, src_format, resume_tokens):
1792
target = self.target_repo
1793
target._unstacked_provider.missing_keys.clear()
1794
candidate_calls = [('Repository.insert_stream_1.19', (1, 19))]
1795
if target._lock_token:
1796
candidate_calls.append(('Repository.insert_stream_locked', (1, 14)))
1797
lock_args = (target._lock_token or '',)
1799
candidate_calls.append(('Repository.insert_stream', (1, 13)))
1801
client = target._client
1802
medium = client._medium
1803
path = target.bzrdir._path_for_remote_call(client)
1804
# Probe for the verb to use with an empty stream before sending the
1805
# real stream to it. We do this both to avoid the risk of sending a
1806
# large request that is then rejected, and because we don't want to
1807
# implement a way to buffer, rewind, or restart the stream.
1809
for verb, required_version in candidate_calls:
1810
if medium._is_remote_before(required_version):
1813
# We've already done the probing (and set _is_remote_before) on
1814
# a previous insert.
1817
byte_stream = smart_repo._stream_to_byte_stream([], src_format)
1819
response = client.call_with_body_stream(
1820
(verb, path, '') + lock_args, byte_stream)
1821
except errors.UnknownSmartMethod:
1822
medium._remember_remote_is_before(required_version)
1828
return self._insert_real(stream, src_format, resume_tokens)
1829
self._last_inv_record = None
1830
self._last_substream = None
1831
if required_version < (1, 19):
1832
# Remote side doesn't support inventory deltas. Wrap the stream to
1833
# make sure we don't send any. If the stream contains inventory
1834
# deltas we'll interrupt the smart insert_stream request and
1836
stream = self._stop_stream_if_inventory_delta(stream)
1837
byte_stream = smart_repo._stream_to_byte_stream(
1839
resume_tokens = ' '.join(resume_tokens)
1840
response = client.call_with_body_stream(
1841
(verb, path, resume_tokens) + lock_args, byte_stream)
1842
if response[0][0] not in ('ok', 'missing-basis'):
1843
raise errors.UnexpectedSmartServerResponse(response)
1844
if self._last_substream is not None:
1845
# The stream included an inventory-delta record, but the remote
1846
# side isn't new enough to support them. So we need to send the
1847
# rest of the stream via VFS.
1848
self.target_repo.refresh_data()
1849
return self._resume_stream_with_vfs(response, src_format)
1850
if response[0][0] == 'missing-basis':
1851
tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1852
resume_tokens = tokens
1853
return resume_tokens, set(missing_keys)
1855
self.target_repo.refresh_data()
1858
def _resume_stream_with_vfs(self, response, src_format):
1859
"""Resume sending a stream via VFS, first resending the record and
1860
substream that couldn't be sent via an insert_stream verb.
1862
if response[0][0] == 'missing-basis':
1863
tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1864
# Ignore missing_keys, we haven't finished inserting yet
1867
def resume_substream():
1868
# Yield the substream that was interrupted.
1869
for record in self._last_substream:
1871
self._last_substream = None
1872
def resume_stream():
1873
# Finish sending the interrupted substream
1874
yield ('inventory-deltas', resume_substream())
1875
# Then simply continue sending the rest of the stream.
1876
for substream_kind, substream in self._last_stream:
1877
yield substream_kind, substream
1878
return self._insert_real(resume_stream(), src_format, tokens)
1880
def _stop_stream_if_inventory_delta(self, stream):
1881
"""Normally this just lets the original stream pass-through unchanged.
1883
However if any 'inventory-deltas' substream occurs it will stop
1884
streaming, and store the interrupted substream and stream in
1885
self._last_substream and self._last_stream so that the stream can be
1886
resumed by _resume_stream_with_vfs.
1889
stream_iter = iter(stream)
1890
for substream_kind, substream in stream_iter:
1891
if substream_kind == 'inventory-deltas':
1892
self._last_substream = substream
1893
self._last_stream = stream_iter
1896
yield substream_kind, substream
1899
class RemoteStreamSource(repository.StreamSource):
1900
"""Stream data from a remote server."""
1902
def get_stream(self, search):
1903
if (self.from_repository._fallback_repositories and
1904
self.to_format._fetch_order == 'topological'):
1905
return self._real_stream(self.from_repository, search)
1908
repos = [self.from_repository]
1914
repos.extend(repo._fallback_repositories)
1915
sources.append(repo)
1916
return self.missing_parents_chain(search, sources)
1918
def get_stream_for_missing_keys(self, missing_keys):
1919
self.from_repository._ensure_real()
1920
real_repo = self.from_repository._real_repository
1921
real_source = real_repo._get_source(self.to_format)
1922
return real_source.get_stream_for_missing_keys(missing_keys)
1924
def _real_stream(self, repo, search):
1925
"""Get a stream for search from repo.
1927
This never called RemoteStreamSource.get_stream, and is a heler
1928
for RemoteStreamSource._get_stream to allow getting a stream
1929
reliably whether fallback back because of old servers or trying
1930
to stream from a non-RemoteRepository (which the stacked support
1933
source = repo._get_source(self.to_format)
1934
if isinstance(source, RemoteStreamSource):
1936
source = repo._real_repository._get_source(self.to_format)
1937
return source.get_stream(search)
1939
def _get_stream(self, repo, search):
1940
"""Core worker to get a stream from repo for search.
1942
This is used by both get_stream and the stacking support logic. It
1943
deliberately gets a stream for repo which does not need to be
1944
self.from_repository. In the event that repo is not Remote, or
1945
cannot do a smart stream, a fallback is made to the generic
1946
repository._get_stream() interface, via self._real_stream.
1948
In the event of stacking, streams from _get_stream will not
1949
contain all the data for search - this is normal (see get_stream).
1951
:param repo: A repository.
1952
:param search: A search.
1954
# Fallbacks may be non-smart
1955
if not isinstance(repo, RemoteRepository):
1956
return self._real_stream(repo, search)
1957
client = repo._client
1958
medium = client._medium
1959
path = repo.bzrdir._path_for_remote_call(client)
1960
search_bytes = repo._serialise_search_result(search)
1961
args = (path, self.to_format.network_name())
1963
('Repository.get_stream_1.19', (1, 19)),
1964
('Repository.get_stream', (1, 13))]
1966
for verb, version in candidate_verbs:
1967
if medium._is_remote_before(version):
1970
response = repo._call_with_body_bytes_expecting_body(
1971
verb, args, search_bytes)
1972
except errors.UnknownSmartMethod:
1973
medium._remember_remote_is_before(version)
1975
response_tuple, response_handler = response
1979
return self._real_stream(repo, search)
1980
if response_tuple[0] != 'ok':
1981
raise errors.UnexpectedSmartServerResponse(response_tuple)
1982
byte_stream = response_handler.read_streamed_body()
1983
src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
1984
self._record_counter)
1985
if src_format.network_name() != repo._format.network_name():
1986
raise AssertionError(
1987
"Mismatched RemoteRepository and stream src %r, %r" % (
1988
src_format.network_name(), repo._format.network_name()))
1991
def missing_parents_chain(self, search, sources):
1992
"""Chain multiple streams together to handle stacking.
1994
:param search: The overall search to satisfy with streams.
1995
:param sources: A list of Repository objects to query.
1997
self.from_serialiser = self.from_repository._format._serializer
1998
self.seen_revs = set()
1999
self.referenced_revs = set()
2000
# If there are heads in the search, or the key count is > 0, we are not
2002
while not search.is_empty() and len(sources) > 1:
2003
source = sources.pop(0)
2004
stream = self._get_stream(source, search)
2005
for kind, substream in stream:
2006
if kind != 'revisions':
2007
yield kind, substream
2009
yield kind, self.missing_parents_rev_handler(substream)
2010
search = search.refine(self.seen_revs, self.referenced_revs)
2011
self.seen_revs = set()
2012
self.referenced_revs = set()
2013
if not search.is_empty():
2014
for kind, stream in self._get_stream(sources[0], search):
2017
def missing_parents_rev_handler(self, substream):
2018
for content in substream:
2019
revision_bytes = content.get_bytes_as('fulltext')
2020
revision = self.from_serialiser.read_revision_from_string(
2022
self.seen_revs.add(content.key[-1])
2023
self.referenced_revs.update(revision.parent_ids)
2027
892
class RemoteBranchLockableFiles(LockableFiles):
2028
893
"""A 'LockableFiles' implementation that talks to a smart server.
2030
895
This is not a public interface class.
2043
908
self._dir_mode = None
2044
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)
2047
930
class RemoteBranchFormat(branch.BranchFormat):
2049
def __init__(self, network_name=None):
2050
super(RemoteBranchFormat, self).__init__()
2051
self._matchingbzrdir = RemoteBzrDirFormat()
2052
self._matchingbzrdir.set_branch_format(self)
2053
self._custom_format = None
2054
self._network_name = network_name
2056
932
def __eq__(self, other):
2057
return (isinstance(other, RemoteBranchFormat) and
933
return (isinstance(other, RemoteBranchFormat) and
2058
934
self.__dict__ == other.__dict__)
2060
def _ensure_real(self):
2061
if self._custom_format is None:
2062
self._custom_format = branch.network_format_registry.get(
2065
936
def get_format_description(self):
2067
return 'Remote: ' + self._custom_format.get_format_description()
2069
def network_name(self):
2070
return self._network_name
2072
def open(self, a_bzrdir, name=None, ignore_fallbacks=False):
2073
return a_bzrdir.open_branch(name=name,
2074
ignore_fallbacks=ignore_fallbacks)
2076
def _vfs_initialize(self, a_bzrdir, name):
2077
# Initialisation when using a local bzrdir object, or a non-vfs init
2078
# method is not available on the server.
2079
# self._custom_format is always set - the start of initialize ensures
2081
if isinstance(a_bzrdir, RemoteBzrDir):
2082
a_bzrdir._ensure_real()
2083
result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2086
# We assume the bzrdir is parameterised; it may not be.
2087
result = self._custom_format.initialize(a_bzrdir, name)
2088
if (isinstance(a_bzrdir, RemoteBzrDir) and
2089
not isinstance(result, RemoteBranch)):
2090
result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2094
def initialize(self, a_bzrdir, name=None):
2095
# 1) get the network name to use.
2096
if self._custom_format:
2097
network_name = self._custom_format.network_name()
2099
# Select the current bzrlib default and ask for that.
2100
reference_bzrdir_format = bzrdir.format_registry.get('default')()
2101
reference_format = reference_bzrdir_format.get_branch_format()
2102
self._custom_format = reference_format
2103
network_name = reference_format.network_name()
2104
# Being asked to create on a non RemoteBzrDir:
2105
if not isinstance(a_bzrdir, RemoteBzrDir):
2106
return self._vfs_initialize(a_bzrdir, name=name)
2107
medium = a_bzrdir._client._medium
2108
if medium._is_remote_before((1, 13)):
2109
return self._vfs_initialize(a_bzrdir, name=name)
2110
# Creating on a remote bzr dir.
2111
# 2) try direct creation via RPC
2112
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2113
if name is not None:
2114
# XXX JRV20100304: Support creating colocated branches
2115
raise errors.NoColocatedBranchSupport(self)
2116
verb = 'BzrDir.create_branch'
2118
response = a_bzrdir._call(verb, path, network_name)
2119
except errors.UnknownSmartMethod:
2120
# Fallback - use vfs methods
2121
medium._remember_remote_is_before((1, 13))
2122
return self._vfs_initialize(a_bzrdir, name=name)
2123
if response[0] != 'ok':
2124
raise errors.UnexpectedSmartServerResponse(response)
2125
# Turn the response into a RemoteRepository object.
2126
format = RemoteBranchFormat(network_name=response[1])
2127
repo_format = response_tuple_to_repo_format(response[3:])
2128
if response[2] == '':
2129
repo_bzrdir = a_bzrdir
2131
repo_bzrdir = RemoteBzrDir(
2132
a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
2134
remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2135
remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2136
format=format, setup_stacking=False, name=name)
2137
# XXX: We know this is a new branch, so it must have revno 0, revid
2138
# NULL_REVISION. Creating the branch locked would make this be unable
2139
# to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2140
remote_branch._last_revision_info_cache = 0, NULL_REVISION
2141
return remote_branch
2143
def make_tags(self, branch):
2145
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()
2147
950
def supports_tags(self):
2148
951
# Remote branches might support tags, but we won't know until we
2149
952
# access the real remote branch.
2151
return self._custom_format.supports_tags()
2153
def supports_stacking(self):
2155
return self._custom_format.supports_stacking()
2157
def supports_set_append_revisions_only(self):
2159
return self._custom_format.supports_set_append_revisions_only()
2162
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
956
class RemoteBranch(branch.Branch):
2163
957
"""Branch stored on a server accessed by HPSS RPC.
2165
959
At the moment most operations are mapped down to simple file operations.
2168
962
def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2169
_client=None, format=None, setup_stacking=True, name=None):
2170
964
"""Create a RemoteBranch instance.
2172
966
:param real_branch: An optional local implementation of the branch
2173
967
format, usually accessing the data via the VFS.
2174
968
:param _client: Private parameter for testing.
2175
:param format: A RemoteBranchFormat object, None to create one
2176
automatically. If supplied it should have a network_name already
2178
:param setup_stacking: If True make an RPC call to determine the
2179
stacked (or not) status of the branch. If False assume the branch
2181
:param name: Colocated branch name
2183
970
# We intentionally don't call the parent class's __init__, because it
2184
971
# will try to assign to self.tags, which is a property in this subclass.
2185
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
2186
975
self.bzrdir = remote_bzrdir
2187
976
if _client is not None:
2188
977
self._client = _client
2190
self._client = remote_bzrdir._client
979
self._client = client._SmartClient(self.bzrdir._shared_medium)
2191
980
self.repository = remote_repository
2192
981
if real_branch is not None:
2193
982
self._real_branch = real_branch
2271
1010
Used before calls to self._real_branch.
2273
if self._real_branch is None:
2274
if not vfs.vfs_enabled():
2275
raise AssertionError('smart server vfs must be enabled '
2276
'to use vfs implementation')
1012
if not self._real_branch:
1013
assert vfs.vfs_enabled()
2277
1014
self.bzrdir._ensure_real()
2278
self._real_branch = self.bzrdir._real_bzrdir.open_branch(
2279
ignore_fallbacks=self._real_ignore_fallbacks, name=self._name)
2280
if self.repository._real_repository is None:
2281
# Give the remote repository the matching real repo.
2282
real_repo = self._real_branch.repository
2283
if isinstance(real_repo, RemoteRepository):
2284
real_repo._ensure_real()
2285
real_repo = real_repo._real_repository
2286
self.repository._set_real_repository(real_repo)
2287
# 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.
2289
1023
self._real_branch.repository = self.repository
1024
# XXX: deal with _lock_mode == 'w'
2290
1025
if self._lock_mode == 'r':
2291
1026
self._real_branch.lock_read()
2292
elif self._lock_mode == 'w':
2293
self._real_branch.lock_write(token=self._lock_token)
2295
def _translate_error(self, err, **context):
2296
self.repository._translate_error(err, branch=self, **context)
2298
def _clear_cached_state(self):
2299
super(RemoteBranch, self)._clear_cached_state()
2300
if self._real_branch is not None:
2301
self._real_branch._clear_cached_state()
2303
def _clear_cached_state_of_remote_branch_only(self):
2304
"""Like _clear_cached_state, but doesn't clear the cache of
2307
This is useful when falling back to calling a method of
2308
self._real_branch that changes state. In that case the underlying
2309
branch changes, so we need to invalidate this RemoteBranch's cache of
2310
it. However, there's no need to invalidate the _real_branch's cache
2311
too, in fact doing so might harm performance.
2313
super(RemoteBranch, self)._clear_cached_state()
2316
1029
def control_files(self):
2331
1044
self._ensure_real()
2332
1045
return self._real_branch.get_physical_lock_status()
2334
def get_stacked_on_url(self):
2335
"""Get the URL this branch is stacked against.
2337
:raises NotStacked: If the branch is not stacked.
2338
:raises UnstackableBranchFormat: If the branch does not support
2340
:raises UnstackableRepositoryFormat: If the repository does not support
2344
# there may not be a repository yet, so we can't use
2345
# self._translate_error, so we can't use self._call either.
2346
response = self._client.call('Branch.get_stacked_on_url',
2347
self._remote_path())
2348
except errors.ErrorFromSmartServer, err:
2349
# there may not be a repository yet, so we can't call through
2350
# its _translate_error
2351
_translate_error(err, branch=self)
2352
except errors.UnknownSmartMethod, err:
2354
return self._real_branch.get_stacked_on_url()
2355
if response[0] != 'ok':
2356
raise errors.UnexpectedSmartServerResponse(response)
2359
def set_stacked_on_url(self, url):
2360
branch.Branch.set_stacked_on_url(self, url)
2362
self._is_stacked = False
2364
self._is_stacked = True
2366
def _vfs_get_tags_bytes(self):
2368
return self._real_branch._get_tags_bytes()
2370
def _get_tags_bytes(self):
2371
medium = self._client._medium
2372
if medium._is_remote_before((1, 13)):
2373
return self._vfs_get_tags_bytes()
2375
response = self._call('Branch.get_tags_bytes', self._remote_path())
2376
except errors.UnknownSmartMethod:
2377
medium._remember_remote_is_before((1, 13))
2378
return self._vfs_get_tags_bytes()
2381
def _vfs_set_tags_bytes(self, bytes):
2383
return self._real_branch._set_tags_bytes(bytes)
2385
def _set_tags_bytes(self, bytes):
2386
medium = self._client._medium
2387
if medium._is_remote_before((1, 18)):
2388
self._vfs_set_tags_bytes(bytes)
2392
self._remote_path(), self._lock_token, self._repo_lock_token)
2393
response = self._call_with_body_bytes(
2394
'Branch.set_tags_bytes', args, bytes)
2395
except errors.UnknownSmartMethod:
2396
medium._remember_remote_is_before((1, 18))
2397
self._vfs_set_tags_bytes(bytes)
2399
1047
def lock_read(self):
2400
"""Lock the branch for read operations.
2402
:return: A bzrlib.lock.LogicalLockResult.
2404
self.repository.lock_read()
2405
1048
if not self._lock_mode:
2406
self._note_lock('r')
2407
1049
self._lock_mode = 'r'
2408
1050
self._lock_count = 1
2409
1051
if self._real_branch is not None:
2410
1052
self._real_branch.lock_read()
2412
1054
self._lock_count += 1
2413
return lock.LogicalLockResult(self.unlock)
2415
1056
def _remote_lock_write(self, token):
2416
1057
if token is None:
2417
1058
branch_token = repo_token = ''
2419
1060
branch_token = token
2420
repo_token = self.repository.lock_write().repository_token
1061
repo_token = self.repository.lock_write()
2421
1062
self.repository.unlock()
2422
err_context = {'token': token}
2424
response = self._call(
2425
'Branch.lock_write', self._remote_path(), branch_token,
2426
repo_token or '', **err_context)
2427
except errors.LockContention, e:
2428
# The LockContention from the server doesn't have any
2429
# information about the lock_url. We re-raise LockContention
2430
# with valid lock_url.
2431
raise errors.LockContention('(remote lock)',
2432
self.repository.base.split('.bzr/')[0])
2433
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])
2434
1080
raise errors.UnexpectedSmartServerResponse(response)
2435
ok, branch_token, repo_token = response
2436
return branch_token, repo_token
2438
1082
def lock_write(self, token=None):
2439
1083
if not self._lock_mode:
2440
self._note_lock('w')
2441
# Lock the branch and repo in one remote call.
2442
1084
remote_tokens = self._remote_lock_write(token)
2443
1085
self._lock_token, self._repo_lock_token = remote_tokens
2444
if not self._lock_token:
2445
raise SmartProtocolError('Remote server did not return a token!')
2446
# Tell the self.repository object that it is locked.
2447
self.repository.lock_write(
2448
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.
2450
1095
if self._real_branch is not None:
2451
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()
2452
1102
if token is not None:
2453
1103
self._leave_lock = True
1105
# XXX: this case seems to be unreachable; token cannot be None.
2455
1106
self._leave_lock = False
2456
1107
self._lock_mode = 'w'
2457
1108
self._lock_count = 1
2458
1109
elif self._lock_mode == 'r':
2459
raise errors.ReadOnlyError(self)
1110
raise errors.ReadOnlyTransaction
2461
1112
if token is not None:
2462
# A token was given to lock_write, and we're relocking, so
2463
# 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.
2465
1115
if token != self._lock_token:
2466
1116
raise errors.TokenMismatch(token, self._lock_token)
2467
1117
self._lock_count += 1
2468
# Re-lock the repository too.
2469
self.repository.lock_write(self._repo_lock_token)
2470
return BranchWriteLockResult(self.unlock, self._lock_token or None)
1118
return self._lock_token or None
2472
1120
def _unlock(self, branch_token, repo_token):
2473
err_context = {'token': str((branch_token, repo_token))}
2474
response = self._call(
2475
'Branch.unlock', self._remote_path(), branch_token,
2476
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,
2477
1124
if response == ('ok',):
2479
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)
2481
@only_raises(errors.LockNotHeld, errors.LockBroken)
2482
1132
def unlock(self):
2484
self._lock_count -= 1
2485
if not self._lock_count:
2486
self._clear_cached_state()
2487
mode = self._lock_mode
2488
self._lock_mode = None
2489
if self._real_branch is not None:
2490
if (not self._leave_lock and mode == 'w' and
2491
self._repo_lock_token):
2492
# If this RemoteBranch will remove the physical lock
2493
# for the repository, make sure the _real_branch
2494
# doesn't do it first. (Because the _real_branch's
2495
# repository is set to be the RemoteRepository.)
2496
self._real_branch.repository.leave_lock_in_place()
2497
self._real_branch.unlock()
2499
# Only write-locked branched need to make a remote method
2500
# call to perform the unlock.
2502
if not self._lock_token:
2503
raise AssertionError('Locked, but no token!')
2504
branch_token = self._lock_token
2505
repo_token = self._repo_lock_token
2506
self._lock_token = None
2507
self._repo_lock_token = None
2508
if not self._leave_lock:
2509
self._unlock(branch_token, repo_token)
2511
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)
2513
1159
def break_lock(self):
2514
1160
self._ensure_real()
2524
1170
raise NotImplementedError(self.dont_leave_lock_in_place)
2525
1171
self._leave_lock = False
2528
def get_rev_id(self, revno, history=None):
2530
return _mod_revision.NULL_REVISION
2531
last_revision_info = self.last_revision_info()
2532
ok, result = self.repository.get_rev_id_for_revno(
2533
revno, last_revision_info)
2536
missing_parent = result[1]
2537
# Either the revision named by the server is missing, or its parent
2538
# is. Call get_parent_map to determine which, so that we report a
2540
parent_map = self.repository.get_parent_map([missing_parent])
2541
if missing_parent in parent_map:
2542
missing_parent = parent_map[missing_parent]
2543
raise errors.RevisionNotPresent(missing_parent, self.repository)
2545
def _last_revision_info(self):
2546
response = self._call('Branch.last_revision_info', self._remote_path())
2547
if response[0] != 'ok':
2548
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,)
2549
1178
revno = int(response[1])
2550
1179
last_revision = response[2]
2551
1180
return (revno, last_revision)
2553
1182
def _gen_revision_history(self):
2554
1183
"""See Branch._gen_revision_history()."""
2555
if self._is_stacked:
2557
return self._real_branch._gen_revision_history()
2558
response_tuple, response_handler = self._call_expecting_body(
2559
'Branch.revision_history', self._remote_path())
2560
if response_tuple[0] != 'ok':
2561
raise errors.UnexpectedSmartServerResponse(response_tuple)
2562
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')
2563
1190
if result == ['']:
2567
def _remote_path(self):
2568
return self.bzrdir._path_for_remote_call(self._client)
2570
def _set_last_revision_descendant(self, revision_id, other_branch,
2571
allow_diverged=False, allow_overwrite_descendant=False):
2572
# This performs additional work to meet the hook contract; while its
2573
# undesirable, we have to synthesise the revno to call the hook, and
2574
# not calling the hook is worse as it means changes can't be prevented.
2575
# Having calculated this though, we can't just call into
2576
# set_last_revision_info as a simple call, because there is a set_rh
2577
# hook that some folk may still be using.
2578
old_revno, old_revid = self.last_revision_info()
2579
history = self._lefthand_history(revision_id)
2580
self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2581
err_context = {'other_branch': other_branch}
2582
response = self._call('Branch.set_last_revision_ex',
2583
self._remote_path(), self._lock_token, self._repo_lock_token,
2584
revision_id, int(allow_diverged), int(allow_overwrite_descendant),
2586
self._clear_cached_state()
2587
if len(response) != 3 and response[0] != 'ok':
2588
raise errors.UnexpectedSmartServerResponse(response)
2589
new_revno, new_revision_id = response[1:]
2590
self._last_revision_info_cache = new_revno, new_revision_id
2591
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2592
if self._real_branch is not None:
2593
cache = new_revno, new_revision_id
2594
self._real_branch._last_revision_info_cache = cache
2596
def _set_last_revision(self, revision_id):
2597
old_revno, old_revid = self.last_revision_info()
2598
# This performs additional work to meet the hook contract; while its
2599
# undesirable, we have to synthesise the revno to call the hook, and
2600
# not calling the hook is worse as it means changes can't be prevented.
2601
# Having calculated this though, we can't just call into
2602
# set_last_revision_info as a simple call, because there is a set_rh
2603
# hook that some folk may still be using.
2604
history = self._lefthand_history(revision_id)
2605
self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2606
self._clear_cached_state()
2607
response = self._call('Branch.set_last_revision',
2608
self._remote_path(), self._lock_token, self._repo_lock_token,
2610
if response != ('ok',):
2611
raise errors.UnexpectedSmartServerResponse(response)
2612
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2614
1194
@needs_write_lock
2615
1195
def set_revision_history(self, rev_history):
2616
1196
# Send just the tip revision of the history; the server will generate
2617
1197
# the full history from that. If the revision doesn't exist in this
2618
1198
# branch, NoSuchRevision will be raised.
1199
path = self.bzrdir._path_for_remote_call(self._client)
2619
1200
if rev_history == []:
2620
1201
rev_id = 'null:'
2622
1203
rev_id = rev_history[-1]
2623
self._set_last_revision(rev_id)
2624
for hook in branch.Branch.hooks['set_rh']:
2625
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,))
2626
1212
self._cache_revision_history(rev_history)
2628
def _get_parent_location(self):
2629
medium = self._client._medium
2630
if medium._is_remote_before((1, 13)):
2631
return self._vfs_get_parent_location()
2633
response = self._call('Branch.get_parent', self._remote_path())
2634
except errors.UnknownSmartMethod:
2635
medium._remember_remote_is_before((1, 13))
2636
return self._vfs_get_parent_location()
2637
if len(response) != 1:
2638
raise errors.UnexpectedSmartServerResponse(response)
2639
parent_location = response[0]
2640
if parent_location == '':
2642
return parent_location
2644
def _vfs_get_parent_location(self):
2646
return self._real_branch._get_parent_location()
2648
def _set_parent_location(self, url):
2649
medium = self._client._medium
2650
if medium._is_remote_before((1, 15)):
2651
return self._vfs_set_parent_location(url)
2653
call_url = url or ''
2654
if type(call_url) is not str:
2655
raise AssertionError('url must be a str or None (%s)' % url)
2656
response = self._call('Branch.set_parent_location',
2657
self._remote_path(), self._lock_token, self._repo_lock_token,
2659
except errors.UnknownSmartMethod:
2660
medium._remember_remote_is_before((1, 15))
2661
return self._vfs_set_parent_location(url)
2663
raise errors.UnexpectedSmartServerResponse(response)
2665
def _vfs_set_parent_location(self, url):
2667
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)
2669
1235
@needs_write_lock
2670
1236
def pull(self, source, overwrite=False, stop_revision=None,
2672
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
2673
1243
self._ensure_real()
2674
return self._real_branch.pull(
1244
self._real_branch.pull(
2675
1245
source, overwrite=overwrite, stop_revision=stop_revision,
2676
_override_hook_target=self, **kwargs)
2678
1248
@needs_read_lock
2679
1249
def push(self, target, overwrite=False, stop_revision=None):
2685
1255
def is_locked(self):
2686
1256
return self._lock_count >= 1
2689
def revision_id_to_revno(self, revision_id):
2691
return self._real_branch.revision_id_to_revno(revision_id)
2694
1258
def set_last_revision_info(self, revno, revision_id):
2695
# XXX: These should be returned by the set_last_revision_info verb
2696
old_revno, old_revid = self.last_revision_info()
2697
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2698
revision_id = ensure_null(revision_id)
2700
response = self._call('Branch.set_last_revision_info',
2701
self._remote_path(), self._lock_token, self._repo_lock_token,
2702
str(revno), revision_id)
2703
except errors.UnknownSmartMethod:
2705
self._clear_cached_state_of_remote_branch_only()
2706
self._real_branch.set_last_revision_info(revno, revision_id)
2707
self._last_revision_info_cache = revno, revision_id
2709
if response == ('ok',):
2710
self._clear_cached_state()
2711
self._last_revision_info_cache = revno, revision_id
2712
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2713
# Update the _real_branch's cache too.
2714
if self._real_branch is not None:
2715
cache = self._last_revision_info_cache
2716
self._real_branch._last_revision_info_cache = cache
2718
raise errors.UnexpectedSmartServerResponse(response)
1260
self._clear_cached_state()
1261
return self._real_branch.set_last_revision_info(revno, revision_id)
2721
1263
def generate_revision_history(self, revision_id, last_rev=None,
2722
1264
other_branch=None):
2723
medium = self._client._medium
2724
if not medium._is_remote_before((1, 6)):
2725
# Use a smart method for 1.6 and above servers
2727
self._set_last_revision_descendant(revision_id, other_branch,
2728
allow_diverged=True, allow_overwrite_descendant=True)
2730
except errors.UnknownSmartMethod:
2731
medium._remember_remote_is_before((1, 6))
2732
self._clear_cached_state_of_remote_branch_only()
2733
self.set_revision_history(self._lefthand_history(revision_id,
2734
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
2736
1274
def set_push_location(self, location):
2737
1275
self._ensure_real()
2738
1276
return self._real_branch.set_push_location(location)
2741
class RemoteConfig(object):
2742
"""A Config that reads and writes from smart verbs.
2744
It is a low-level object that considers config data to be name/value pairs
2745
that may be associated with a section. Assigning meaning to the these
2746
values is done at higher levels like bzrlib.config.TreeConfig.
2749
def get_option(self, name, section=None, default=None):
2750
"""Return the value associated with a named option.
2752
:param name: The name of the value
2753
:param section: The section the option is in (if any)
2754
:param default: The value to return if the value is not set
2755
:return: The value or default value
2758
configobj = self._get_configobj()
2760
section_obj = configobj
2763
section_obj = configobj[section]
2766
return section_obj.get(name, default)
2767
except errors.UnknownSmartMethod:
2768
return self._vfs_get_option(name, section, default)
2770
def _response_to_configobj(self, response):
2771
if len(response[0]) and response[0][0] != 'ok':
2772
raise errors.UnexpectedSmartServerResponse(response)
2773
lines = response[1].read_body_bytes().splitlines()
2774
return config.ConfigObj(lines, encoding='utf-8')
2777
class RemoteBranchConfig(RemoteConfig):
2778
"""A RemoteConfig for Branches."""
2780
def __init__(self, branch):
2781
self._branch = branch
2783
def _get_configobj(self):
2784
path = self._branch._remote_path()
2785
response = self._branch._client.call_expecting_body(
2786
'Branch.get_config_file', path)
2787
return self._response_to_configobj(response)
2789
def set_option(self, value, name, section=None):
2790
"""Set the value associated with a named option.
2792
:param value: The value to set
2793
:param name: The name of the value to set
2794
:param section: The section the option is in (if any)
2796
medium = self._branch._client._medium
2797
if medium._is_remote_before((1, 14)):
2798
return self._vfs_set_option(value, name, section)
2799
if isinstance(value, dict):
2800
if medium._is_remote_before((2, 2)):
2801
return self._vfs_set_option(value, name, section)
2802
return self._set_config_option_dict(value, name, section)
2804
return self._set_config_option(value, name, section)
2806
def _set_config_option(self, value, name, section):
2808
path = self._branch._remote_path()
2809
response = self._branch._client.call('Branch.set_config_option',
2810
path, self._branch._lock_token, self._branch._repo_lock_token,
2811
value.encode('utf8'), name, section or '')
2812
except errors.UnknownSmartMethod:
2813
medium = self._branch._client._medium
2814
medium._remember_remote_is_before((1, 14))
2815
return self._vfs_set_option(value, name, section)
2817
raise errors.UnexpectedSmartServerResponse(response)
2819
def _serialize_option_dict(self, option_dict):
2821
for key, value in option_dict.items():
2822
if isinstance(key, unicode):
2823
key = key.encode('utf8')
2824
if isinstance(value, unicode):
2825
value = value.encode('utf8')
2826
utf8_dict[key] = value
2827
return bencode.bencode(utf8_dict)
2829
def _set_config_option_dict(self, value, name, section):
2831
path = self._branch._remote_path()
2832
serialised_dict = self._serialize_option_dict(value)
2833
response = self._branch._client.call(
2834
'Branch.set_config_option_dict',
2835
path, self._branch._lock_token, self._branch._repo_lock_token,
2836
serialised_dict, name, section or '')
2837
except errors.UnknownSmartMethod:
2838
medium = self._branch._client._medium
2839
medium._remember_remote_is_before((2, 2))
2840
return self._vfs_set_option(value, name, section)
2842
raise errors.UnexpectedSmartServerResponse(response)
2844
def _real_object(self):
2845
self._branch._ensure_real()
2846
return self._branch._real_branch
2848
def _vfs_set_option(self, value, name, section=None):
2849
return self._real_object()._get_config().set_option(
2850
value, name, section)
2853
class RemoteBzrDirConfig(RemoteConfig):
2854
"""A RemoteConfig for BzrDirs."""
2856
def __init__(self, bzrdir):
2857
self._bzrdir = bzrdir
2859
def _get_configobj(self):
2860
medium = self._bzrdir._client._medium
2861
verb = 'BzrDir.get_config_file'
2862
if medium._is_remote_before((1, 15)):
2863
raise errors.UnknownSmartMethod(verb)
2864
path = self._bzrdir._path_for_remote_call(self._bzrdir._client)
2865
response = self._bzrdir._call_expecting_body(
2867
return self._response_to_configobj(response)
2869
def _vfs_get_option(self, name, section, default):
2870
return self._real_object()._get_config().get_option(
2871
name, section, default)
2873
def set_option(self, value, name, section=None):
2874
"""Set the value associated with a named option.
2876
:param value: The value to set
2877
:param name: The name of the value to set
2878
:param section: The section the option is in (if any)
2880
return self._real_object()._get_config().set_option(
2881
value, name, section)
2883
def _real_object(self):
2884
self._bzrdir._ensure_real()
2885
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
2889
1297
def _extract_tar(tar, to_dir):
2894
1302
for tarinfo in tar:
2895
1303
tar.extract(tarinfo, to_dir)
2898
def _translate_error(err, **context):
2899
"""Translate an ErrorFromSmartServer into a more useful error.
2901
Possible context keys:
2909
If the error from the server doesn't match a known pattern, then
2910
UnknownErrorFromSmartServer is raised.
2914
return context[name]
2915
except KeyError, key_err:
2916
mutter('Missing key %r in context %r', key_err.args[0], context)
2919
"""Get the path from the context if present, otherwise use first error
2923
return context['path']
2924
except KeyError, key_err:
2926
return err.error_args[0]
2927
except IndexError, idx_err:
2929
'Missing key %r in context %r', key_err.args[0], context)
2932
if err.error_verb == 'IncompatibleRepositories':
2933
raise errors.IncompatibleRepositories(err.error_args[0],
2934
err.error_args[1], err.error_args[2])
2935
elif err.error_verb == 'NoSuchRevision':
2936
raise NoSuchRevision(find('branch'), err.error_args[0])
2937
elif err.error_verb == 'nosuchrevision':
2938
raise NoSuchRevision(find('repository'), err.error_args[0])
2939
elif err.error_verb == 'nobranch':
2940
if len(err.error_args) >= 1:
2941
extra = err.error_args[0]
2944
raise errors.NotBranchError(path=find('bzrdir').root_transport.base,
2946
elif err.error_verb == 'norepository':
2947
raise errors.NoRepositoryPresent(find('bzrdir'))
2948
elif err.error_verb == 'LockContention':
2949
raise errors.LockContention('(remote lock)')
2950
elif err.error_verb == 'UnlockableTransport':
2951
raise errors.UnlockableTransport(find('bzrdir').root_transport)
2952
elif err.error_verb == 'LockFailed':
2953
raise errors.LockFailed(err.error_args[0], err.error_args[1])
2954
elif err.error_verb == 'TokenMismatch':
2955
raise errors.TokenMismatch(find('token'), '(remote token)')
2956
elif err.error_verb == 'Diverged':
2957
raise errors.DivergedBranches(find('branch'), find('other_branch'))
2958
elif err.error_verb == 'TipChangeRejected':
2959
raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
2960
elif err.error_verb == 'UnstackableBranchFormat':
2961
raise errors.UnstackableBranchFormat(*err.error_args)
2962
elif err.error_verb == 'UnstackableRepositoryFormat':
2963
raise errors.UnstackableRepositoryFormat(*err.error_args)
2964
elif err.error_verb == 'NotStacked':
2965
raise errors.NotStacked(branch=find('branch'))
2966
elif err.error_verb == 'PermissionDenied':
2968
if len(err.error_args) >= 2:
2969
extra = err.error_args[1]
2972
raise errors.PermissionDenied(path, extra=extra)
2973
elif err.error_verb == 'ReadError':
2975
raise errors.ReadError(path)
2976
elif err.error_verb == 'NoSuchFile':
2978
raise errors.NoSuchFile(path)
2979
elif err.error_verb == 'FileExists':
2980
raise errors.FileExists(err.error_args[0])
2981
elif err.error_verb == 'DirectoryNotEmpty':
2982
raise errors.DirectoryNotEmpty(err.error_args[0])
2983
elif err.error_verb == 'ShortReadvError':
2984
args = err.error_args
2985
raise errors.ShortReadvError(
2986
args[0], int(args[1]), int(args[2]), int(args[3]))
2987
elif err.error_verb in ('UnicodeEncodeError', 'UnicodeDecodeError'):
2988
encoding = str(err.error_args[0]) # encoding must always be a string
2989
val = err.error_args[1]
2990
start = int(err.error_args[2])
2991
end = int(err.error_args[3])
2992
reason = str(err.error_args[4]) # reason must always be a string
2993
if val.startswith('u:'):
2994
val = val[2:].decode('utf-8')
2995
elif val.startswith('s:'):
2996
val = val[2:].decode('base64')
2997
if err.error_verb == 'UnicodeDecodeError':
2998
raise UnicodeDecodeError(encoding, val, start, end, reason)
2999
elif err.error_verb == 'UnicodeEncodeError':
3000
raise UnicodeEncodeError(encoding, val, start, end, reason)
3001
elif err.error_verb == 'ReadOnlyError':
3002
raise errors.TransportNotPossible('readonly transport')
3003
raise errors.UnknownErrorFromSmartServer(err)
added
removed
bzrlib/remote.py
