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., 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
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22
19
from bzrlib import (
30
repository as _mod_repository,
32
revision as _mod_revision,
28
from bzrlib.branch import Branch, BranchReferenceFormat
36
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
29
37
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
30
from bzrlib.config import BranchConfig, TreeConfig
31
from bzrlib.decorators import needs_read_lock, needs_write_lock
32
from bzrlib.errors import NoSuchRevision
38
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
39
from bzrlib.errors import (
33
43
from bzrlib.lockable_files import LockableFiles
34
from bzrlib.pack import ContainerReader
35
from bzrlib.revision import NULL_REVISION
36
from bzrlib.smart import client, vfs
37
from bzrlib.symbol_versioning import (
41
from bzrlib.trace import note
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]
43
90
# Note: RemoteBzrDirFormat is in bzrdir.py
45
class RemoteBzrDir(BzrDir):
92
class RemoteBzrDir(BzrDir, _RpcHelper):
46
93
"""Control directory on a remote server, accessed via bzr:// or similar."""
48
def __init__(self, transport, _client=None):
95
def __init__(self, transport, format, _client=None, _force_probe=False):
49
96
"""Construct a RemoteBzrDir.
51
98
:param _client: Private parameter for testing. Disables probing and the
52
99
use of a real bzrdir.
54
BzrDir.__init__(self, transport, RemoteBzrDirFormat())
101
BzrDir.__init__(self, transport, format)
55
102
# this object holds a delegated bzrdir that uses file-level operations
56
103
# to talk to the other side
57
104
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
59
110
if _client is None:
60
self._shared_medium = transport.get_shared_medium()
61
self._client = client._SmartClient(self._shared_medium)
111
medium = transport.get_smart_medium()
112
self._client = client._SmartClient(medium)
63
114
self._client = _client
64
self._shared_medium = None
121
return '%s(%r)' % (self.__class__.__name__, self._client)
123
def _probe_bzrdir(self):
124
medium = self._client._medium
67
125
path = self._path_for_remote_call(self._client)
68
response = self._client.call('BzrDir.open', path)
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)
69
152
if response not in [('yes',), ('no',)]:
70
153
raise errors.UnexpectedSmartServerResponse(response)
71
154
if response == ('no',):
72
raise errors.NotBranchError(path=transport.base)
155
raise errors.NotBranchError(path=self.root_transport.base)
74
157
def _ensure_real(self):
75
158
"""Ensure that there is a _real_bzrdir set.
77
160
Used before calls to self._real_bzrdir.
79
162
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()))
80
167
self._real_bzrdir = BzrDir.open_from_transport(
81
168
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)
83
234
def create_repository(self, shared=False):
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):
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):
94
268
"""See BzrDir.destroy_branch"""
95
269
self._ensure_real()
96
self._real_bzrdir.destroy_branch()
270
self._real_bzrdir.destroy_branch(name=name)
271
self._next_open_branch_result = None
98
def create_workingtree(self, revision_id=None):
273
def create_workingtree(self, revision_id=None, from_branch=None):
99
274
raise errors.NotLocalUrl(self.transport.base)
101
276
def find_branch_format(self):
109
284
def get_branch_reference(self):
110
285
"""See BzrDir.get_branch_reference()."""
286
response = self._get_branch_reference()
287
if response[0] == 'ref':
292
def _get_branch_reference(self):
111
293
path = self._path_for_remote_call(self._client)
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)
294
medium = self._client._medium
296
('BzrDir.open_branchV3', (2, 1)),
297
('BzrDir.open_branchV2', (1, 13)),
298
('BzrDir.open_branch', None),
300
for verb, required_version in candidate_calls:
301
if required_version and medium._is_remote_before(required_version):
304
response = self._call(verb, path)
305
except errors.UnknownSmartMethod:
306
if required_version is None:
308
medium._remember_remote_is_before(required_version)
311
if verb == 'BzrDir.open_branch':
312
if response[0] != 'ok':
313
raise errors.UnexpectedSmartServerResponse(response)
314
if response[1] != '':
315
return ('ref', response[1])
317
return ('branch', '')
318
if response[0] not in ('ref', 'branch'):
123
319
raise errors.UnexpectedSmartServerResponse(response)
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())
322
def _get_tree_branch(self):
323
"""See BzrDir._get_tree_branch()."""
324
return None, self.open_branch()
326
def open_branch(self, name=None, unsupported=False,
327
ignore_fallbacks=False):
329
raise NotImplementedError('unsupported flag support not implemented yet.')
330
if self._next_open_branch_result is not None:
331
# See create_branch for details.
332
result = self._next_open_branch_result
333
self._next_open_branch_result = None
335
response = self._get_branch_reference()
336
if response[0] == 'ref':
132
337
# a branch reference, use the existing BranchReference logic.
133
338
format = BranchReferenceFormat()
134
return format.open(self, _found=True, location=reference_url)
339
return format.open(self, name=name, _found=True,
340
location=response[1], ignore_fallbacks=ignore_fallbacks)
341
branch_format_name = response[1]
342
if not branch_format_name:
343
branch_format_name = None
344
format = RemoteBranchFormat(network_name=branch_format_name)
345
return RemoteBranch(self, self.find_repository(), format=format,
346
setup_stacking=not ignore_fallbacks, name=name)
348
def _open_repo_v1(self, path):
349
verb = 'BzrDir.find_repository'
350
response = self._call(verb, path)
351
if response[0] != 'ok':
352
raise errors.UnexpectedSmartServerResponse(response)
353
# servers that only support the v1 method don't support external
356
repo = self._real_bzrdir.open_repository()
357
response = response + ('no', repo._format.network_name())
358
return response, repo
360
def _open_repo_v2(self, path):
361
verb = 'BzrDir.find_repositoryV2'
362
response = self._call(verb, path)
363
if response[0] != 'ok':
364
raise errors.UnexpectedSmartServerResponse(response)
366
repo = self._real_bzrdir.open_repository()
367
response = response + (repo._format.network_name(),)
368
return response, repo
370
def _open_repo_v3(self, path):
371
verb = 'BzrDir.find_repositoryV3'
372
medium = self._client._medium
373
if medium._is_remote_before((1, 13)):
374
raise errors.UnknownSmartMethod(verb)
376
response = self._call(verb, path)
377
except errors.UnknownSmartMethod:
378
medium._remember_remote_is_before((1, 13))
380
if response[0] != 'ok':
381
raise errors.UnexpectedSmartServerResponse(response)
382
return response, None
136
384
def open_repository(self):
137
385
path = self._path_for_remote_call(self._client)
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,)
387
for probe in [self._open_repo_v3, self._open_repo_v2,
390
response, real_repo = probe(path)
392
except errors.UnknownSmartMethod:
395
raise errors.UnknownSmartMethod('BzrDir.find_repository{3,2,}')
396
if response[0] != 'ok':
397
raise errors.UnexpectedSmartServerResponse(response)
398
if len(response) != 6:
399
raise SmartProtocolError('incorrect response length %s' % (response,))
144
400
if response[1] == '':
145
format = RemoteRepositoryFormat()
146
format.rich_root_data = (response[2] == 'yes')
147
format.supports_tree_reference = (response[3] == 'yes')
148
return RemoteRepository(self, format)
401
# repo is at this dir.
402
format = response_tuple_to_repo_format(response[2:])
403
# Used to support creating a real format instance when needed.
404
format._creating_bzrdir = self
405
remote_repo = RemoteRepository(self, format)
406
format._creating_repo = remote_repo
407
if real_repo is not None:
408
remote_repo._set_real_repository(real_repo)
150
411
raise errors.NoRepositoryPresent(self)
413
def has_workingtree(self):
414
if self._has_working_tree is None:
416
self._has_working_tree = self._real_bzrdir.has_workingtree()
417
return self._has_working_tree
152
419
def open_workingtree(self, recommend_upgrade=True):
154
if self._real_bzrdir.has_workingtree():
420
if self.has_workingtree():
155
421
raise errors.NotLocalUrl(self.root_transport)
157
423
raise errors.NoWorkingTree(self.root_transport.base)
192
465
Instances of this repository are represented by RemoteRepository
195
The RemoteRepositoryFormat is parameterised during construction
468
The RemoteRepositoryFormat is parameterized during construction
196
469
to reflect the capabilities of the real, remote format. Specifically
197
470
the attributes rich_root_data and supports_tree_reference are set
198
471
on a per instance basis, and are not set (and should not be) at
474
:ivar _custom_format: If set, a specific concrete repository format that
475
will be used when initializing a repository with this
476
RemoteRepositoryFormat.
477
:ivar _creating_repo: If set, the repository object that this
478
RemoteRepositoryFormat was created for: it can be called into
479
to obtain data like the network name.
202
_matchingbzrdir = RemoteBzrDirFormat
482
_matchingbzrdir = RemoteBzrDirFormat()
485
repository.RepositoryFormat.__init__(self)
486
self._custom_format = None
487
self._network_name = None
488
self._creating_bzrdir = None
489
self._supports_chks = None
490
self._supports_external_lookups = None
491
self._supports_tree_reference = None
492
self._rich_root_data = None
495
return "%s(_network_name=%r)" % (self.__class__.__name__,
499
def fast_deltas(self):
501
return self._custom_format.fast_deltas
504
def rich_root_data(self):
505
if self._rich_root_data is None:
507
self._rich_root_data = self._custom_format.rich_root_data
508
return self._rich_root_data
511
def supports_chks(self):
512
if self._supports_chks is None:
514
self._supports_chks = self._custom_format.supports_chks
515
return self._supports_chks
518
def supports_external_lookups(self):
519
if self._supports_external_lookups is None:
521
self._supports_external_lookups = \
522
self._custom_format.supports_external_lookups
523
return self._supports_external_lookups
526
def supports_tree_reference(self):
527
if self._supports_tree_reference is None:
529
self._supports_tree_reference = \
530
self._custom_format.supports_tree_reference
531
return self._supports_tree_reference
533
def _vfs_initialize(self, a_bzrdir, shared):
534
"""Helper for common code in initialize."""
535
if self._custom_format:
536
# Custom format requested
537
result = self._custom_format.initialize(a_bzrdir, shared=shared)
538
elif self._creating_bzrdir is not None:
539
# Use the format that the repository we were created to back
541
prior_repo = self._creating_bzrdir.open_repository()
542
prior_repo._ensure_real()
543
result = prior_repo._real_repository._format.initialize(
544
a_bzrdir, shared=shared)
546
# assume that a_bzr is a RemoteBzrDir but the smart server didn't
547
# support remote initialization.
548
# We delegate to a real object at this point (as RemoteBzrDir
549
# delegate to the repository format which would lead to infinite
550
# recursion if we just called a_bzrdir.create_repository.
551
a_bzrdir._ensure_real()
552
result = a_bzrdir._real_bzrdir.create_repository(shared=shared)
553
if not isinstance(result, RemoteRepository):
554
return self.open(a_bzrdir)
204
558
def initialize(self, a_bzrdir, shared=False):
205
assert isinstance(a_bzrdir, RemoteBzrDir), \
206
'%r is not a RemoteBzrDir' % (a_bzrdir,)
207
return a_bzrdir.create_repository(shared=shared)
559
# Being asked to create on a non RemoteBzrDir:
560
if not isinstance(a_bzrdir, RemoteBzrDir):
561
return self._vfs_initialize(a_bzrdir, shared)
562
medium = a_bzrdir._client._medium
563
if medium._is_remote_before((1, 13)):
564
return self._vfs_initialize(a_bzrdir, shared)
565
# Creating on a remote bzr dir.
566
# 1) get the network name to use.
567
if self._custom_format:
568
network_name = self._custom_format.network_name()
569
elif self._network_name:
570
network_name = self._network_name
572
# Select the current bzrlib default and ask for that.
573
reference_bzrdir_format = bzrdir.format_registry.get('default')()
574
reference_format = reference_bzrdir_format.repository_format
575
network_name = reference_format.network_name()
576
# 2) try direct creation via RPC
577
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
578
verb = 'BzrDir.create_repository'
584
response = a_bzrdir._call(verb, path, network_name, shared_str)
585
except errors.UnknownSmartMethod:
586
# Fallback - use vfs methods
587
medium._remember_remote_is_before((1, 13))
588
return self._vfs_initialize(a_bzrdir, shared)
590
# Turn the response into a RemoteRepository object.
591
format = response_tuple_to_repo_format(response[1:])
592
# Used to support creating a real format instance when needed.
593
format._creating_bzrdir = a_bzrdir
594
remote_repo = RemoteRepository(a_bzrdir, format)
595
format._creating_repo = remote_repo
209
598
def open(self, a_bzrdir):
210
assert isinstance(a_bzrdir, RemoteBzrDir)
599
if not isinstance(a_bzrdir, RemoteBzrDir):
600
raise AssertionError('%r is not a RemoteBzrDir' % (a_bzrdir,))
211
601
return a_bzrdir.open_repository()
603
def _ensure_real(self):
604
if self._custom_format is None:
605
self._custom_format = repository.network_format_registry.get(
609
def _fetch_order(self):
611
return self._custom_format._fetch_order
614
def _fetch_uses_deltas(self):
616
return self._custom_format._fetch_uses_deltas
619
def _fetch_reconcile(self):
621
return self._custom_format._fetch_reconcile
213
623
def get_format_description(self):
214
return 'bzr remote repository'
625
return 'Remote: ' + self._custom_format.get_format_description()
216
627
def __eq__(self, other):
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):
628
return self.__class__ is other.__class__
630
def network_name(self):
631
if self._network_name:
632
return self._network_name
633
self._creating_repo._ensure_real()
634
return self._creating_repo._real_repository._format.network_name()
637
def pack_compresses(self):
639
return self._custom_format.pack_compresses
642
def _serializer(self):
644
return self._custom_format._serializer
647
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
648
bzrdir.ControlComponent):
230
649
"""Repository accessed over rpc.
232
651
For the moment most operations are performed using local transport-backed
258
677
self._lock_token = None
259
678
self._lock_count = 0
260
679
self._leave_lock = False
262
self._reconcile_does_inventory_gc = True
263
self._reconcile_fixes_text_parents = True
680
# Cache of revision parents; misses are cached during read locks, and
681
# write locks when no _real_repository has been set.
682
self._unstacked_provider = graph.CachingParentsProvider(
683
get_parent_map=self._get_parent_map_rpc)
684
self._unstacked_provider.disable_cache()
686
# These depend on the actual remote format, so force them off for
687
# maximum compatibility. XXX: In future these should depend on the
688
# remote repository instance, but this is irrelevant until we perform
689
# reconcile via an RPC call.
690
self._reconcile_does_inventory_gc = False
691
self._reconcile_fixes_text_parents = False
692
self._reconcile_backsup_inventory = False
264
693
self.base = self.bzrdir.transport.base
694
# Additional places to query for data.
695
self._fallback_repositories = []
698
def user_transport(self):
699
return self.bzrdir.user_transport
702
def control_transport(self):
703
# XXX: Normally you shouldn't directly get at the remote repository
704
# transport, but I'm not sure it's worth making this method
705
# optional -- mbp 2010-04-21
706
return self.bzrdir.get_repository_transport(None)
266
708
def __str__(self):
267
709
return "%s(%s)" % (self.__class__.__name__, self.base)
269
711
__repr__ = __str__
271
def abort_write_group(self):
713
def abort_write_group(self, suppress_errors=False):
272
714
"""Complete a write group on the decorated repository.
274
Smart methods peform operations in a single step so this api
716
Smart methods perform operations in a single step so this API
275
717
is not really applicable except as a compatibility thunk
276
718
for older plugins that don't use e.g. the CommitBuilder
280
return self._real_repository.abort_write_group()
721
:param suppress_errors: see Repository.abort_write_group.
724
return self._real_repository.abort_write_group(
725
suppress_errors=suppress_errors)
729
"""Decorate the real repository for now.
731
In the long term a full blown network facility is needed to avoid
732
creating a real repository object locally.
735
return self._real_repository.chk_bytes
282
737
def commit_write_group(self):
283
738
"""Complete a write group on the decorated repository.
285
Smart methods peform operations in a single step so this api
740
Smart methods perform operations in a single step so this API
286
741
is not really applicable except as a compatibility thunk
287
742
for older plugins that don't use e.g. the CommitBuilder
290
745
self._ensure_real()
291
746
return self._real_repository.commit_write_group()
748
def resume_write_group(self, tokens):
750
return self._real_repository.resume_write_group(tokens)
752
def suspend_write_group(self):
754
return self._real_repository.suspend_write_group()
756
def get_missing_parent_inventories(self, check_for_missing_texts=True):
758
return self._real_repository.get_missing_parent_inventories(
759
check_for_missing_texts=check_for_missing_texts)
761
def _get_rev_id_for_revno_vfs(self, revno, known_pair):
763
return self._real_repository.get_rev_id_for_revno(
766
def get_rev_id_for_revno(self, revno, known_pair):
767
"""See Repository.get_rev_id_for_revno."""
768
path = self.bzrdir._path_for_remote_call(self._client)
770
if self._client._medium._is_remote_before((1, 17)):
771
return self._get_rev_id_for_revno_vfs(revno, known_pair)
772
response = self._call(
773
'Repository.get_rev_id_for_revno', path, revno, known_pair)
774
except errors.UnknownSmartMethod:
775
self._client._medium._remember_remote_is_before((1, 17))
776
return self._get_rev_id_for_revno_vfs(revno, known_pair)
777
if response[0] == 'ok':
778
return True, response[1]
779
elif response[0] == 'history-incomplete':
780
known_pair = response[1:3]
781
for fallback in self._fallback_repositories:
782
found, result = fallback.get_rev_id_for_revno(revno, known_pair)
787
# Not found in any fallbacks
788
return False, known_pair
790
raise errors.UnexpectedSmartServerResponse(response)
293
792
def _ensure_real(self):
294
793
"""Ensure that there is a _real_repository set.
296
795
Used before calls to self._real_repository.
797
Note that _ensure_real causes many roundtrips to the server which are
798
not desirable, and prevents the use of smart one-roundtrip RPC's to
799
perform complex operations (such as accessing parent data, streaming
800
revisions etc). Adding calls to _ensure_real should only be done when
801
bringing up new functionality, adding fallbacks for smart methods that
802
require a fallback path, and never to replace an existing smart method
803
invocation. If in doubt chat to the bzr network team.
298
if not self._real_repository:
805
if self._real_repository is None:
806
if 'hpssvfs' in debug.debug_flags:
808
warning('VFS Repository access triggered\n%s',
809
''.join(traceback.format_stack()))
810
self._unstacked_provider.missing_keys.clear()
299
811
self.bzrdir._ensure_real()
300
#self._real_repository = self.bzrdir._real_bzrdir.open_repository()
301
self._set_real_repository(self.bzrdir._real_bzrdir.open_repository())
303
def get_revision_graph(self, revision_id=None):
304
"""See Repository.get_revision_graph()."""
812
self._set_real_repository(
813
self.bzrdir._real_bzrdir.open_repository())
815
def _translate_error(self, err, **context):
816
self.bzrdir._translate_error(err, repository=self, **context)
818
def find_text_key_references(self):
819
"""Find the text key references within the repository.
821
:return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
822
revision_ids. Each altered file-ids has the exact revision_ids that
823
altered it listed explicitly.
824
:return: A dictionary mapping text keys ((fileid, revision_id) tuples)
825
to whether they were referred to by the inventory of the
826
revision_id that they contain. The inventory texts from all present
827
revision ids are assessed to generate this report.
830
return self._real_repository.find_text_key_references()
832
def _generate_text_key_index(self):
833
"""Generate a new text key index for the repository.
835
This is an expensive function that will take considerable time to run.
837
:return: A dict mapping (file_id, revision_id) tuples to a list of
838
parents, also (file_id, revision_id) tuples.
841
return self._real_repository._generate_text_key_index()
843
def _get_revision_graph(self, revision_id):
844
"""Private method for using with old (< 1.2) servers to fallback."""
305
845
if revision_id is None:
307
elif revision_id == NULL_REVISION:
847
elif revision.is_null(revision_id):
310
850
path = self.bzrdir._path_for_remote_call(self._client)
311
assert type(revision_id) is str
312
response = self._client.call_expecting_body(
851
response = self._call_expecting_body(
313
852
'Repository.get_revision_graph', path, revision_id)
314
if response[0][0] not in ['ok', 'nosuchrevision']:
315
raise errors.UnexpectedSmartServerResponse(response[0])
316
if response[0][0] == 'ok':
317
coded = response[1].read_body_bytes()
319
# no revisions in this repository!
321
lines = coded.split('\n')
324
d = tuple(line.split())
325
revision_graph[d[0]] = d[1:]
327
return revision_graph
329
response_body = response[1].read_body_bytes()
330
assert response_body == ''
331
raise NoSuchRevision(self, revision_id)
853
response_tuple, response_handler = response
854
if response_tuple[0] != 'ok':
855
raise errors.UnexpectedSmartServerResponse(response_tuple)
856
coded = response_handler.read_body_bytes()
858
# no revisions in this repository!
860
lines = coded.split('\n')
863
d = tuple(line.split())
864
revision_graph[d[0]] = d[1:]
866
return revision_graph
869
"""See Repository._get_sink()."""
870
return RemoteStreamSink(self)
872
def _get_source(self, to_format):
873
"""Return a source for streaming from this repository."""
874
return RemoteStreamSource(self, to_format)
333
877
def has_revision(self, revision_id):
334
"""See Repository.has_revision()."""
335
if revision_id is None:
336
# The null revision is always present.
338
path = self.bzrdir._path_for_remote_call(self._client)
339
response = self._client.call('Repository.has_revision', path, revision_id)
340
assert response[0] in ('yes', 'no'), 'unexpected response code %s' % (response,)
341
return response[0] == 'yes'
878
"""True if this repository has a copy of the revision."""
879
# Copy of bzrlib.repository.Repository.has_revision
880
return revision_id in self.has_revisions((revision_id,))
883
def has_revisions(self, revision_ids):
884
"""Probe to find out the presence of multiple revisions.
886
:param revision_ids: An iterable of revision_ids.
887
:return: A set of the revision_ids that were present.
889
# Copy of bzrlib.repository.Repository.has_revisions
890
parent_map = self.get_parent_map(revision_ids)
891
result = set(parent_map)
892
if _mod_revision.NULL_REVISION in revision_ids:
893
result.add(_mod_revision.NULL_REVISION)
896
def _has_same_fallbacks(self, other_repo):
897
"""Returns true if the repositories have the same fallbacks."""
898
# XXX: copied from Repository; it should be unified into a base class
899
# <https://bugs.edge.launchpad.net/bzr/+bug/401622>
900
my_fb = self._fallback_repositories
901
other_fb = other_repo._fallback_repositories
902
if len(my_fb) != len(other_fb):
904
for f, g in zip(my_fb, other_fb):
905
if not f.has_same_location(g):
343
909
def has_same_location(self, other):
344
return (self.__class__ == other.__class__ and
910
# TODO: Move to RepositoryBase and unify with the regular Repository
911
# one; unfortunately the tests rely on slightly different behaviour at
912
# present -- mbp 20090710
913
return (self.__class__ is other.__class__ and
345
914
self.bzrdir.transport.base == other.bzrdir.transport.base)
347
916
def get_graph(self, other_repository=None):
348
917
"""Return the graph for this repository format"""
350
return self._real_repository.get_graph(other_repository)
918
parents_provider = self._make_parents_provider(other_repository)
919
return graph.Graph(parents_provider)
922
def get_known_graph_ancestry(self, revision_ids):
923
"""Return the known graph for a set of revision ids and their ancestors.
925
st = static_tuple.StaticTuple
926
revision_keys = [st(r_id).intern() for r_id in revision_ids]
927
known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
928
return graph.GraphThunkIdsToKeys(known_graph)
352
930
def gather_stats(self, revid=None, committers=None):
353
931
"""See Repository.gather_stats()."""
354
932
path = self.bzrdir._path_for_remote_call(self._client)
355
if revid in (None, NULL_REVISION):
933
# revid can be None to indicate no revisions, not just NULL_REVISION
934
if revid is None or revision.is_null(revid):
358
937
fmt_revid = revid
397
984
def is_shared(self):
398
985
"""See Repository.is_shared()."""
399
986
path = self.bzrdir._path_for_remote_call(self._client)
400
response = self._client.call('Repository.is_shared', path)
401
assert response[0] in ('yes', 'no'), 'unexpected response code %s' % (response,)
987
response = self._call('Repository.is_shared', path)
988
if response[0] not in ('yes', 'no'):
989
raise SmartProtocolError('unexpected response code %s' % (response,))
402
990
return response[0] == 'yes'
404
992
def is_write_locked(self):
405
993
return self._lock_mode == 'w'
995
def _warn_if_deprecated(self, branch=None):
996
# If we have a real repository, the check will be done there, if we
997
# don't the check will be done remotely.
407
1000
def lock_read(self):
1001
"""Lock the repository for read operations.
1003
:return: An object with an unlock method which will release the lock
408
1006
# wrong eventually - want a local lock cache context
409
1007
if not self._lock_mode:
1008
self._note_lock('r')
410
1009
self._lock_mode = 'r'
411
1010
self._lock_count = 1
1011
self._unstacked_provider.enable_cache(cache_misses=True)
412
1012
if self._real_repository is not None:
413
1013
self._real_repository.lock_read()
1014
for repo in self._fallback_repositories:
415
1017
self._lock_count += 1
417
1020
def _remote_lock_write(self, token):
418
1021
path = self.bzrdir._path_for_remote_call(self._client)
419
1022
if token is None:
421
response = self._client.call('Repository.lock_write', path, token)
1024
err_context = {'token': token}
1025
response = self._call('Repository.lock_write', path, token,
422
1027
if response[0] == 'ok':
423
1028
ok, token = response
425
elif response[0] == 'LockContention':
426
raise errors.LockContention('(remote lock)')
427
elif response[0] == 'UnlockableTransport':
428
raise errors.UnlockableTransport(self.bzrdir.root_transport)
429
elif response[0] == 'LockFailed':
430
raise errors.LockFailed(response[1], response[2])
432
1031
raise errors.UnexpectedSmartServerResponse(response)
434
def lock_write(self, token=None):
1033
def lock_write(self, token=None, _skip_rpc=False):
435
1034
if not self._lock_mode:
436
self._lock_token = self._remote_lock_write(token)
437
assert self._lock_token, 'Remote server did not return a token!'
1035
self._note_lock('w')
1037
if self._lock_token is not None:
1038
if token != self._lock_token:
1039
raise errors.TokenMismatch(token, self._lock_token)
1040
self._lock_token = token
1042
self._lock_token = self._remote_lock_write(token)
1043
# if self._lock_token is None, then this is something like packs or
1044
# svn where we don't get to lock the repo, or a weave style repository
1045
# where we cannot lock it over the wire and attempts to do so will
438
1047
if self._real_repository is not None:
439
1048
self._real_repository.lock_write(token=self._lock_token)
440
1049
if token is not None:
564
1225
# FIXME: It ought to be possible to call this without immediately
565
1226
# triggering _ensure_real. For now it's the easiest thing to do.
566
1227
self._ensure_real()
567
builder = self._real_repository.get_commit_builder(branch, parents,
1228
real_repo = self._real_repository
1229
builder = real_repo.get_commit_builder(branch, parents,
568
1230
config, timestamp=timestamp, timezone=timezone,
569
1231
committer=committer, revprops=revprops, revision_id=revision_id)
570
# Make the builder use this RemoteRepository rather than the real one.
571
builder.repository = self
1234
def add_fallback_repository(self, repository):
1235
"""Add a repository to use for looking up data not held locally.
1237
:param repository: A repository.
1239
if not self._format.supports_external_lookups:
1240
raise errors.UnstackableRepositoryFormat(
1241
self._format.network_name(), self.base)
1242
# We need to accumulate additional repositories here, to pass them in
1245
if self.is_locked():
1246
# We will call fallback.unlock() when we transition to the unlocked
1247
# state, so always add a lock here. If a caller passes us a locked
1248
# repository, they are responsible for unlocking it later.
1249
repository.lock_read()
1250
self._check_fallback_repository(repository)
1251
self._fallback_repositories.append(repository)
1252
# If self._real_repository was parameterised already (e.g. because a
1253
# _real_branch had its get_stacked_on_url method called), then the
1254
# repository to be added may already be in the _real_repositories list.
1255
if self._real_repository is not None:
1256
fallback_locations = [repo.user_url for repo in
1257
self._real_repository._fallback_repositories]
1258
if repository.user_url not in fallback_locations:
1259
self._real_repository.add_fallback_repository(repository)
1261
def _check_fallback_repository(self, repository):
1262
"""Check that this repository can fallback to repository safely.
1264
Raise an error if not.
1266
:param repository: A repository to fallback to.
1268
return _mod_repository.InterRepository._assert_same_model(
575
1271
def add_inventory(self, revid, inv, parents):
576
1272
self._ensure_real()
577
1273
return self._real_repository.add_inventory(revid, inv, parents)
1275
def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1276
parents, basis_inv=None, propagate_caches=False):
1278
return self._real_repository.add_inventory_by_delta(basis_revision_id,
1279
delta, new_revision_id, parents, basis_inv=basis_inv,
1280
propagate_caches=propagate_caches)
580
1282
def add_revision(self, rev_id, rev, inv=None, config=None):
581
1283
self._ensure_real()
582
1284
return self._real_repository.add_revision(
607
1308
return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
609
1310
def make_working_trees(self):
610
"""RemoteRepositories never create working trees by default."""
613
def fetch(self, source, revision_id=None, pb=None):
614
if self.has_same_location(source):
1311
"""See Repository.make_working_trees"""
1313
return self._real_repository.make_working_trees()
1315
def refresh_data(self):
1316
"""Re-read any data needed to to synchronise with disk.
1318
This method is intended to be called after another repository instance
1319
(such as one used by a smart server) has inserted data into the
1320
repository. It may not be called during a write group, but may be
1321
called at any other time.
1323
if self.is_in_write_group():
1324
raise errors.InternalBzrError(
1325
"May not refresh_data while in a write group.")
1326
if self._real_repository is not None:
1327
self._real_repository.refresh_data()
1329
def revision_ids_to_search_result(self, result_set):
1330
"""Convert a set of revision ids to a graph SearchResult."""
1331
result_parents = set()
1332
for parents in self.get_graph().get_parent_map(
1333
result_set).itervalues():
1334
result_parents.update(parents)
1335
included_keys = result_set.intersection(result_parents)
1336
start_keys = result_set.difference(included_keys)
1337
exclude_keys = result_parents.difference(result_set)
1338
result = graph.SearchResult(start_keys, exclude_keys,
1339
len(result_set), result_set)
1343
def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1344
"""Return the revision ids that other has that this does not.
1346
These are returned in topological order.
1348
revision_id: only return revision ids included by revision_id.
1350
return repository.InterRepository.get(
1351
other, self).search_missing_revision_ids(revision_id, find_ghosts)
1353
def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
1355
# No base implementation to use as RemoteRepository is not a subclass
1356
# of Repository; so this is a copy of Repository.fetch().
1357
if fetch_spec is not None and revision_id is not None:
1358
raise AssertionError(
1359
"fetch_spec and revision_id are mutually exclusive.")
1360
if self.is_in_write_group():
1361
raise errors.InternalBzrError(
1362
"May not fetch while in a write group.")
1363
# fast path same-url fetch operations
1364
if (self.has_same_location(source)
1365
and fetch_spec is None
1366
and self._has_same_fallbacks(source)):
615
1367
# check that last_revision is in 'from' and then return a
617
1369
if (revision_id is not None and
618
not _mod_revision.is_null(revision_id)):
1370
not revision.is_null(revision_id)):
619
1371
self.get_revision(revision_id)
622
return self._real_repository.fetch(
623
source, revision_id=revision_id, pb=pb)
1373
# if there is no specific appropriate InterRepository, this will get
1374
# the InterRepository base class, which raises an
1375
# IncompatibleRepositories when asked to fetch.
1376
inter = repository.InterRepository.get(source, self)
1377
return inter.fetch(revision_id=revision_id, pb=pb,
1378
find_ghosts=find_ghosts, fetch_spec=fetch_spec)
625
1380
def create_bundle(self, target, base, fileobj, format=None):
626
1381
self._ensure_real()
627
1382
self._real_repository.create_bundle(target, base, fileobj, format)
630
def control_weaves(self):
632
return self._real_repository.control_weaves
634
1384
@needs_read_lock
635
1385
def get_ancestry(self, revision_id, topo_sorted=True):
636
1386
self._ensure_real()
637
1387
return self._real_repository.get_ancestry(revision_id, topo_sorted)
640
def get_inventory_weave(self):
642
return self._real_repository.get_inventory_weave()
644
1389
def fileids_altered_by_revision_ids(self, revision_ids):
645
1390
self._ensure_real()
646
1391
return self._real_repository.fileids_altered_by_revision_ids(revision_ids)
648
def get_versioned_file_checker(self, revisions, revision_versions_cache):
1393
def _get_versioned_file_checker(self, revisions, revision_versions_cache):
649
1394
self._ensure_real()
650
return self._real_repository.get_versioned_file_checker(
1395
return self._real_repository._get_versioned_file_checker(
651
1396
revisions, revision_versions_cache)
653
1398
def iter_files_bytes(self, desired_files):
654
1399
"""See Repository.iter_file_bytes.
656
1401
self._ensure_real()
657
1402
return self._real_repository.iter_files_bytes(desired_files)
1404
def get_parent_map(self, revision_ids):
1405
"""See bzrlib.Graph.get_parent_map()."""
1406
return self._make_parents_provider().get_parent_map(revision_ids)
1408
def _get_parent_map_rpc(self, keys):
1409
"""Helper for get_parent_map that performs the RPC."""
1410
medium = self._client._medium
1411
if medium._is_remote_before((1, 2)):
1412
# We already found out that the server can't understand
1413
# Repository.get_parent_map requests, so just fetch the whole
1416
# Note that this reads the whole graph, when only some keys are
1417
# wanted. On this old server there's no way (?) to get them all
1418
# in one go, and the user probably will have seen a warning about
1419
# the server being old anyhow.
1420
rg = self._get_revision_graph(None)
1421
# There is an API discrepancy between get_parent_map and
1422
# get_revision_graph. Specifically, a "key:()" pair in
1423
# get_revision_graph just means a node has no parents. For
1424
# "get_parent_map" it means the node is a ghost. So fix up the
1425
# graph to correct this.
1426
# https://bugs.launchpad.net/bzr/+bug/214894
1427
# There is one other "bug" which is that ghosts in
1428
# get_revision_graph() are not returned at all. But we won't worry
1429
# about that for now.
1430
for node_id, parent_ids in rg.iteritems():
1431
if parent_ids == ():
1432
rg[node_id] = (NULL_REVISION,)
1433
rg[NULL_REVISION] = ()
1438
raise ValueError('get_parent_map(None) is not valid')
1439
if NULL_REVISION in keys:
1440
keys.discard(NULL_REVISION)
1441
found_parents = {NULL_REVISION:()}
1443
return found_parents
1446
# TODO(Needs analysis): We could assume that the keys being requested
1447
# from get_parent_map are in a breadth first search, so typically they
1448
# will all be depth N from some common parent, and we don't have to
1449
# have the server iterate from the root parent, but rather from the
1450
# keys we're searching; and just tell the server the keyspace we
1451
# already have; but this may be more traffic again.
1453
# Transform self._parents_map into a search request recipe.
1454
# TODO: Manage this incrementally to avoid covering the same path
1455
# repeatedly. (The server will have to on each request, but the less
1456
# work done the better).
1458
# Negative caching notes:
1459
# new server sends missing when a request including the revid
1460
# 'include-missing:' is present in the request.
1461
# missing keys are serialised as missing:X, and we then call
1462
# provider.note_missing(X) for-all X
1463
parents_map = self._unstacked_provider.get_cached_map()
1464
if parents_map is None:
1465
# Repository is not locked, so there's no cache.
1467
# start_set is all the keys in the cache
1468
start_set = set(parents_map)
1469
# result set is all the references to keys in the cache
1470
result_parents = set()
1471
for parents in parents_map.itervalues():
1472
result_parents.update(parents)
1473
stop_keys = result_parents.difference(start_set)
1474
# We don't need to send ghosts back to the server as a position to
1476
stop_keys.difference_update(self._unstacked_provider.missing_keys)
1477
key_count = len(parents_map)
1478
if (NULL_REVISION in result_parents
1479
and NULL_REVISION in self._unstacked_provider.missing_keys):
1480
# If we pruned NULL_REVISION from the stop_keys because it's also
1481
# in our cache of "missing" keys we need to increment our key count
1482
# by 1, because the reconsitituted SearchResult on the server will
1483
# still consider NULL_REVISION to be an included key.
1485
included_keys = start_set.intersection(result_parents)
1486
start_set.difference_update(included_keys)
1487
recipe = ('manual', start_set, stop_keys, key_count)
1488
body = self._serialise_search_recipe(recipe)
1489
path = self.bzrdir._path_for_remote_call(self._client)
1491
if type(key) is not str:
1493
"key %r not a plain string" % (key,))
1494
verb = 'Repository.get_parent_map'
1495
args = (path, 'include-missing:') + tuple(keys)
1497
response = self._call_with_body_bytes_expecting_body(
1499
except errors.UnknownSmartMethod:
1500
# Server does not support this method, so get the whole graph.
1501
# Worse, we have to force a disconnection, because the server now
1502
# doesn't realise it has a body on the wire to consume, so the
1503
# only way to recover is to abandon the connection.
1505
'Server is too old for fast get_parent_map, reconnecting. '
1506
'(Upgrade the server to Bazaar 1.2 to avoid this)')
1508
# To avoid having to disconnect repeatedly, we keep track of the
1509
# fact the server doesn't understand remote methods added in 1.2.
1510
medium._remember_remote_is_before((1, 2))
1511
# Recurse just once and we should use the fallback code.
1512
return self._get_parent_map_rpc(keys)
1513
response_tuple, response_handler = response
1514
if response_tuple[0] not in ['ok']:
1515
response_handler.cancel_read_body()
1516
raise errors.UnexpectedSmartServerResponse(response_tuple)
1517
if response_tuple[0] == 'ok':
1518
coded = bz2.decompress(response_handler.read_body_bytes())
1520
# no revisions found
1522
lines = coded.split('\n')
1525
d = tuple(line.split())
1527
revision_graph[d[0]] = d[1:]
1530
if d[0].startswith('missing:'):
1532
self._unstacked_provider.note_missing_key(revid)
1534
# no parents - so give the Graph result
1536
revision_graph[d[0]] = (NULL_REVISION,)
1537
return revision_graph
659
1539
@needs_read_lock
660
1540
def get_signature_text(self, revision_id):
661
1541
self._ensure_real()
662
1542
return self._real_repository.get_signature_text(revision_id)
664
1544
@needs_read_lock
665
def get_revision_graph_with_ghosts(self, revision_ids=None):
667
return self._real_repository.get_revision_graph_with_ghosts(
668
revision_ids=revision_ids)
671
def get_inventory_xml(self, revision_id):
673
return self._real_repository.get_inventory_xml(revision_id)
675
def deserialise_inventory(self, revision_id, xml):
677
return self._real_repository.deserialise_inventory(revision_id, xml)
1545
def _get_inventory_xml(self, revision_id):
1547
return self._real_repository._get_inventory_xml(revision_id)
679
1549
def reconcile(self, other=None, thorough=False):
680
1550
self._ensure_real()
681
1551
return self._real_repository.reconcile(other=other, thorough=thorough)
683
1553
def all_revision_ids(self):
684
1554
self._ensure_real()
685
1555
return self._real_repository.all_revision_ids()
688
def get_deltas_for_revisions(self, revisions):
690
return self._real_repository.get_deltas_for_revisions(revisions)
693
def get_revision_delta(self, revision_id):
695
return self._real_repository.get_revision_delta(revision_id)
1558
def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1560
return self._real_repository.get_deltas_for_revisions(revisions,
1561
specific_fileids=specific_fileids)
1564
def get_revision_delta(self, revision_id, specific_fileids=None):
1566
return self._real_repository.get_revision_delta(revision_id,
1567
specific_fileids=specific_fileids)
697
1569
@needs_read_lock
698
1570
def revision_trees(self, revision_ids):
832
1726
self._ensure_real()
833
1727
return self._real_repository.revision_graph_can_have_wrong_parents()
835
def _find_inconsistent_revision_parents(self):
1729
def _find_inconsistent_revision_parents(self, revisions_iterator=None):
836
1730
self._ensure_real()
837
return self._real_repository._find_inconsistent_revision_parents()
1731
return self._real_repository._find_inconsistent_revision_parents(
839
1734
def _check_for_inconsistent_revision_parents(self):
840
1735
self._ensure_real()
841
1736
return self._real_repository._check_for_inconsistent_revision_parents()
1738
def _make_parents_provider(self, other=None):
1739
providers = [self._unstacked_provider]
1740
if other is not None:
1741
providers.insert(0, other)
1742
providers.extend(r._make_parents_provider() for r in
1743
self._fallback_repositories)
1744
return graph.StackedParentsProvider(providers)
1746
def _serialise_search_recipe(self, recipe):
1747
"""Serialise a graph search recipe.
1749
:param recipe: A search recipe (start, stop, count).
1750
:return: Serialised bytes.
1752
start_keys = ' '.join(recipe[1])
1753
stop_keys = ' '.join(recipe[2])
1754
count = str(recipe[3])
1755
return '\n'.join((start_keys, stop_keys, count))
1757
def _serialise_search_result(self, search_result):
1758
if isinstance(search_result, graph.PendingAncestryResult):
1759
parts = ['ancestry-of']
1760
parts.extend(search_result.heads)
1762
recipe = search_result.get_recipe()
1763
parts = [recipe[0], self._serialise_search_recipe(recipe)]
1764
return '\n'.join(parts)
1767
path = self.bzrdir._path_for_remote_call(self._client)
1769
response = self._call('PackRepository.autopack', path)
1770
except errors.UnknownSmartMethod:
1772
self._real_repository._pack_collection.autopack()
1775
if response[0] != 'ok':
1776
raise errors.UnexpectedSmartServerResponse(response)
1779
class RemoteStreamSink(repository.StreamSink):
1781
def _insert_real(self, stream, src_format, resume_tokens):
1782
self.target_repo._ensure_real()
1783
sink = self.target_repo._real_repository._get_sink()
1784
result = sink.insert_stream(stream, src_format, resume_tokens)
1786
self.target_repo.autopack()
1789
def insert_stream(self, stream, src_format, resume_tokens):
1790
target = self.target_repo
1791
target._unstacked_provider.missing_keys.clear()
1792
candidate_calls = [('Repository.insert_stream_1.19', (1, 19))]
1793
if target._lock_token:
1794
candidate_calls.append(('Repository.insert_stream_locked', (1, 14)))
1795
lock_args = (target._lock_token or '',)
1797
candidate_calls.append(('Repository.insert_stream', (1, 13)))
1799
client = target._client
1800
medium = client._medium
1801
path = target.bzrdir._path_for_remote_call(client)
1802
# Probe for the verb to use with an empty stream before sending the
1803
# real stream to it. We do this both to avoid the risk of sending a
1804
# large request that is then rejected, and because we don't want to
1805
# implement a way to buffer, rewind, or restart the stream.
1807
for verb, required_version in candidate_calls:
1808
if medium._is_remote_before(required_version):
1811
# We've already done the probing (and set _is_remote_before) on
1812
# a previous insert.
1815
byte_stream = smart_repo._stream_to_byte_stream([], src_format)
1817
response = client.call_with_body_stream(
1818
(verb, path, '') + lock_args, byte_stream)
1819
except errors.UnknownSmartMethod:
1820
medium._remember_remote_is_before(required_version)
1826
return self._insert_real(stream, src_format, resume_tokens)
1827
self._last_inv_record = None
1828
self._last_substream = None
1829
if required_version < (1, 19):
1830
# Remote side doesn't support inventory deltas. Wrap the stream to
1831
# make sure we don't send any. If the stream contains inventory
1832
# deltas we'll interrupt the smart insert_stream request and
1834
stream = self._stop_stream_if_inventory_delta(stream)
1835
byte_stream = smart_repo._stream_to_byte_stream(
1837
resume_tokens = ' '.join(resume_tokens)
1838
response = client.call_with_body_stream(
1839
(verb, path, resume_tokens) + lock_args, byte_stream)
1840
if response[0][0] not in ('ok', 'missing-basis'):
1841
raise errors.UnexpectedSmartServerResponse(response)
1842
if self._last_substream is not None:
1843
# The stream included an inventory-delta record, but the remote
1844
# side isn't new enough to support them. So we need to send the
1845
# rest of the stream via VFS.
1846
self.target_repo.refresh_data()
1847
return self._resume_stream_with_vfs(response, src_format)
1848
if response[0][0] == 'missing-basis':
1849
tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1850
resume_tokens = tokens
1851
return resume_tokens, set(missing_keys)
1853
self.target_repo.refresh_data()
1856
def _resume_stream_with_vfs(self, response, src_format):
1857
"""Resume sending a stream via VFS, first resending the record and
1858
substream that couldn't be sent via an insert_stream verb.
1860
if response[0][0] == 'missing-basis':
1861
tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1862
# Ignore missing_keys, we haven't finished inserting yet
1865
def resume_substream():
1866
# Yield the substream that was interrupted.
1867
for record in self._last_substream:
1869
self._last_substream = None
1870
def resume_stream():
1871
# Finish sending the interrupted substream
1872
yield ('inventory-deltas', resume_substream())
1873
# Then simply continue sending the rest of the stream.
1874
for substream_kind, substream in self._last_stream:
1875
yield substream_kind, substream
1876
return self._insert_real(resume_stream(), src_format, tokens)
1878
def _stop_stream_if_inventory_delta(self, stream):
1879
"""Normally this just lets the original stream pass-through unchanged.
1881
However if any 'inventory-deltas' substream occurs it will stop
1882
streaming, and store the interrupted substream and stream in
1883
self._last_substream and self._last_stream so that the stream can be
1884
resumed by _resume_stream_with_vfs.
1887
stream_iter = iter(stream)
1888
for substream_kind, substream in stream_iter:
1889
if substream_kind == 'inventory-deltas':
1890
self._last_substream = substream
1891
self._last_stream = stream_iter
1894
yield substream_kind, substream
1897
class RemoteStreamSource(repository.StreamSource):
1898
"""Stream data from a remote server."""
1900
def get_stream(self, search):
1901
if (self.from_repository._fallback_repositories and
1902
self.to_format._fetch_order == 'topological'):
1903
return self._real_stream(self.from_repository, search)
1906
repos = [self.from_repository]
1912
repos.extend(repo._fallback_repositories)
1913
sources.append(repo)
1914
return self.missing_parents_chain(search, sources)
1916
def get_stream_for_missing_keys(self, missing_keys):
1917
self.from_repository._ensure_real()
1918
real_repo = self.from_repository._real_repository
1919
real_source = real_repo._get_source(self.to_format)
1920
return real_source.get_stream_for_missing_keys(missing_keys)
1922
def _real_stream(self, repo, search):
1923
"""Get a stream for search from repo.
1925
This never called RemoteStreamSource.get_stream, and is a heler
1926
for RemoteStreamSource._get_stream to allow getting a stream
1927
reliably whether fallback back because of old servers or trying
1928
to stream from a non-RemoteRepository (which the stacked support
1931
source = repo._get_source(self.to_format)
1932
if isinstance(source, RemoteStreamSource):
1934
source = repo._real_repository._get_source(self.to_format)
1935
return source.get_stream(search)
1937
def _get_stream(self, repo, search):
1938
"""Core worker to get a stream from repo for search.
1940
This is used by both get_stream and the stacking support logic. It
1941
deliberately gets a stream for repo which does not need to be
1942
self.from_repository. In the event that repo is not Remote, or
1943
cannot do a smart stream, a fallback is made to the generic
1944
repository._get_stream() interface, via self._real_stream.
1946
In the event of stacking, streams from _get_stream will not
1947
contain all the data for search - this is normal (see get_stream).
1949
:param repo: A repository.
1950
:param search: A search.
1952
# Fallbacks may be non-smart
1953
if not isinstance(repo, RemoteRepository):
1954
return self._real_stream(repo, search)
1955
client = repo._client
1956
medium = client._medium
1957
path = repo.bzrdir._path_for_remote_call(client)
1958
search_bytes = repo._serialise_search_result(search)
1959
args = (path, self.to_format.network_name())
1961
('Repository.get_stream_1.19', (1, 19)),
1962
('Repository.get_stream', (1, 13))]
1964
for verb, version in candidate_verbs:
1965
if medium._is_remote_before(version):
1968
response = repo._call_with_body_bytes_expecting_body(
1969
verb, args, search_bytes)
1970
except errors.UnknownSmartMethod:
1971
medium._remember_remote_is_before(version)
1973
response_tuple, response_handler = response
1977
return self._real_stream(repo, search)
1978
if response_tuple[0] != 'ok':
1979
raise errors.UnexpectedSmartServerResponse(response_tuple)
1980
byte_stream = response_handler.read_streamed_body()
1981
src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
1982
if src_format.network_name() != repo._format.network_name():
1983
raise AssertionError(
1984
"Mismatched RemoteRepository and stream src %r, %r" % (
1985
src_format.network_name(), repo._format.network_name()))
1988
def missing_parents_chain(self, search, sources):
1989
"""Chain multiple streams together to handle stacking.
1991
:param search: The overall search to satisfy with streams.
1992
:param sources: A list of Repository objects to query.
1994
self.from_serialiser = self.from_repository._format._serializer
1995
self.seen_revs = set()
1996
self.referenced_revs = set()
1997
# If there are heads in the search, or the key count is > 0, we are not
1999
while not search.is_empty() and len(sources) > 1:
2000
source = sources.pop(0)
2001
stream = self._get_stream(source, search)
2002
for kind, substream in stream:
2003
if kind != 'revisions':
2004
yield kind, substream
2006
yield kind, self.missing_parents_rev_handler(substream)
2007
search = search.refine(self.seen_revs, self.referenced_revs)
2008
self.seen_revs = set()
2009
self.referenced_revs = set()
2010
if not search.is_empty():
2011
for kind, stream in self._get_stream(sources[0], search):
2014
def missing_parents_rev_handler(self, substream):
2015
for content in substream:
2016
revision_bytes = content.get_bytes_as('fulltext')
2017
revision = self.from_serialiser.read_revision_from_string(
2019
self.seen_revs.add(content.key[-1])
2020
self.referenced_revs.update(revision.parent_ids)
844
2024
class RemoteBranchLockableFiles(LockableFiles):
845
2025
"""A 'LockableFiles' implementation that talks to a smart server.
847
2027
This is not a public interface class.
860
2040
self._dir_mode = None
861
2041
self._file_mode = None
864
"""'get' a remote path as per the LockableFiles interface.
866
:param path: the file to 'get'. If this is 'branch.conf', we do not
867
just retrieve a file, instead we ask the smart server to generate
868
a configuration for us - which is retrieved as an INI file.
870
if path == 'branch.conf':
871
path = self.bzrdir._path_for_remote_call(self._client)
872
response = self._client.call_expecting_body(
873
'Branch.get_config_file', path)
874
assert response[0][0] == 'ok', \
875
'unexpected response code %s' % (response[0],)
876
return StringIO(response[1].read_body_bytes())
879
return LockableFiles.get(self, path)
882
2044
class RemoteBranchFormat(branch.BranchFormat):
2046
def __init__(self, network_name=None):
2047
super(RemoteBranchFormat, self).__init__()
2048
self._matchingbzrdir = RemoteBzrDirFormat()
2049
self._matchingbzrdir.set_branch_format(self)
2050
self._custom_format = None
2051
self._network_name = network_name
884
2053
def __eq__(self, other):
885
return (isinstance(other, RemoteBranchFormat) and
2054
return (isinstance(other, RemoteBranchFormat) and
886
2055
self.__dict__ == other.__dict__)
2057
def _ensure_real(self):
2058
if self._custom_format is None:
2059
self._custom_format = branch.network_format_registry.get(
888
2062
def get_format_description(self):
889
return 'Remote BZR Branch'
891
def get_format_string(self):
892
return 'Remote BZR Branch'
894
def open(self, a_bzrdir):
895
assert isinstance(a_bzrdir, RemoteBzrDir)
896
return a_bzrdir.open_branch()
898
def initialize(self, a_bzrdir):
899
assert isinstance(a_bzrdir, RemoteBzrDir)
900
return a_bzrdir.create_branch()
2064
return 'Remote: ' + self._custom_format.get_format_description()
2066
def network_name(self):
2067
return self._network_name
2069
def open(self, a_bzrdir, name=None, ignore_fallbacks=False):
2070
return a_bzrdir.open_branch(name=name,
2071
ignore_fallbacks=ignore_fallbacks)
2073
def _vfs_initialize(self, a_bzrdir, name):
2074
# Initialisation when using a local bzrdir object, or a non-vfs init
2075
# method is not available on the server.
2076
# self._custom_format is always set - the start of initialize ensures
2078
if isinstance(a_bzrdir, RemoteBzrDir):
2079
a_bzrdir._ensure_real()
2080
result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2083
# We assume the bzrdir is parameterised; it may not be.
2084
result = self._custom_format.initialize(a_bzrdir, name)
2085
if (isinstance(a_bzrdir, RemoteBzrDir) and
2086
not isinstance(result, RemoteBranch)):
2087
result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2091
def initialize(self, a_bzrdir, name=None):
2092
# 1) get the network name to use.
2093
if self._custom_format:
2094
network_name = self._custom_format.network_name()
2096
# Select the current bzrlib default and ask for that.
2097
reference_bzrdir_format = bzrdir.format_registry.get('default')()
2098
reference_format = reference_bzrdir_format.get_branch_format()
2099
self._custom_format = reference_format
2100
network_name = reference_format.network_name()
2101
# Being asked to create on a non RemoteBzrDir:
2102
if not isinstance(a_bzrdir, RemoteBzrDir):
2103
return self._vfs_initialize(a_bzrdir, name=name)
2104
medium = a_bzrdir._client._medium
2105
if medium._is_remote_before((1, 13)):
2106
return self._vfs_initialize(a_bzrdir, name=name)
2107
# Creating on a remote bzr dir.
2108
# 2) try direct creation via RPC
2109
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2110
if name is not None:
2111
# XXX JRV20100304: Support creating colocated branches
2112
raise errors.NoColocatedBranchSupport(self)
2113
verb = 'BzrDir.create_branch'
2115
response = a_bzrdir._call(verb, path, network_name)
2116
except errors.UnknownSmartMethod:
2117
# Fallback - use vfs methods
2118
medium._remember_remote_is_before((1, 13))
2119
return self._vfs_initialize(a_bzrdir, name=name)
2120
if response[0] != 'ok':
2121
raise errors.UnexpectedSmartServerResponse(response)
2122
# Turn the response into a RemoteRepository object.
2123
format = RemoteBranchFormat(network_name=response[1])
2124
repo_format = response_tuple_to_repo_format(response[3:])
2125
if response[2] == '':
2126
repo_bzrdir = a_bzrdir
2128
repo_bzrdir = RemoteBzrDir(
2129
a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
2131
remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2132
remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2133
format=format, setup_stacking=False, name=name)
2134
# XXX: We know this is a new branch, so it must have revno 0, revid
2135
# NULL_REVISION. Creating the branch locked would make this be unable
2136
# to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2137
remote_branch._last_revision_info_cache = 0, NULL_REVISION
2138
return remote_branch
2140
def make_tags(self, branch):
2142
return self._custom_format.make_tags(branch)
902
2144
def supports_tags(self):
903
2145
# Remote branches might support tags, but we won't know until we
904
2146
# access the real remote branch.
908
class RemoteBranch(branch.Branch):
2148
return self._custom_format.supports_tags()
2150
def supports_stacking(self):
2152
return self._custom_format.supports_stacking()
2154
def supports_set_append_revisions_only(self):
2156
return self._custom_format.supports_set_append_revisions_only()
2159
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
909
2160
"""Branch stored on a server accessed by HPSS RPC.
911
2162
At the moment most operations are mapped down to simple file operations.
914
2165
def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2166
_client=None, format=None, setup_stacking=True, name=None):
916
2167
"""Create a RemoteBranch instance.
918
2169
:param real_branch: An optional local implementation of the branch
919
2170
format, usually accessing the data via the VFS.
920
2171
:param _client: Private parameter for testing.
2172
:param format: A RemoteBranchFormat object, None to create one
2173
automatically. If supplied it should have a network_name already
2175
:param setup_stacking: If True make an RPC call to determine the
2176
stacked (or not) status of the branch. If False assume the branch
2178
:param name: Colocated branch name
922
2180
# We intentionally don't call the parent class's __init__, because it
923
2181
# will try to assign to self.tags, which is a property in this subclass.
924
2182
# And the parent's __init__ doesn't do much anyway.
925
self._revision_history_cache = None
926
2183
self.bzrdir = remote_bzrdir
927
2184
if _client is not None:
928
2185
self._client = _client
930
self._client = client._SmartClient(self.bzrdir._shared_medium)
2187
self._client = remote_bzrdir._client
931
2188
self.repository = remote_repository
932
2189
if real_branch is not None:
933
2190
self._real_branch = real_branch
961
2268
Used before calls to self._real_branch.
963
if not self._real_branch:
964
assert vfs.vfs_enabled()
2270
if self._real_branch is None:
2271
if not vfs.vfs_enabled():
2272
raise AssertionError('smart server vfs must be enabled '
2273
'to use vfs implementation')
965
2274
self.bzrdir._ensure_real()
966
self._real_branch = self.bzrdir._real_bzrdir.open_branch()
967
# Give the remote repository the matching real repo.
968
real_repo = self._real_branch.repository
969
if isinstance(real_repo, RemoteRepository):
970
real_repo._ensure_real()
971
real_repo = real_repo._real_repository
972
self.repository._set_real_repository(real_repo)
973
# Give the branch the remote repository to let fast-pathing happen.
2275
self._real_branch = self.bzrdir._real_bzrdir.open_branch(
2276
ignore_fallbacks=self._real_ignore_fallbacks, name=self._name)
2277
if self.repository._real_repository is None:
2278
# Give the remote repository the matching real repo.
2279
real_repo = self._real_branch.repository
2280
if isinstance(real_repo, RemoteRepository):
2281
real_repo._ensure_real()
2282
real_repo = real_repo._real_repository
2283
self.repository._set_real_repository(real_repo)
2284
# Give the real branch the remote repository to let fast-pathing
974
2286
self._real_branch.repository = self.repository
975
# XXX: deal with _lock_mode == 'w'
976
2287
if self._lock_mode == 'r':
977
2288
self._real_branch.lock_read()
2289
elif self._lock_mode == 'w':
2290
self._real_branch.lock_write(token=self._lock_token)
2292
def _translate_error(self, err, **context):
2293
self.repository._translate_error(err, branch=self, **context)
2295
def _clear_cached_state(self):
2296
super(RemoteBranch, self)._clear_cached_state()
2297
if self._real_branch is not None:
2298
self._real_branch._clear_cached_state()
2300
def _clear_cached_state_of_remote_branch_only(self):
2301
"""Like _clear_cached_state, but doesn't clear the cache of
2304
This is useful when falling back to calling a method of
2305
self._real_branch that changes state. In that case the underlying
2306
branch changes, so we need to invalidate this RemoteBranch's cache of
2307
it. However, there's no need to invalidate the _real_branch's cache
2308
too, in fact doing so might harm performance.
2310
super(RemoteBranch, self)._clear_cached_state()
980
2313
def control_files(self):
995
2328
self._ensure_real()
996
2329
return self._real_branch.get_physical_lock_status()
2331
def get_stacked_on_url(self):
2332
"""Get the URL this branch is stacked against.
2334
:raises NotStacked: If the branch is not stacked.
2335
:raises UnstackableBranchFormat: If the branch does not support
2337
:raises UnstackableRepositoryFormat: If the repository does not support
2341
# there may not be a repository yet, so we can't use
2342
# self._translate_error, so we can't use self._call either.
2343
response = self._client.call('Branch.get_stacked_on_url',
2344
self._remote_path())
2345
except errors.ErrorFromSmartServer, err:
2346
# there may not be a repository yet, so we can't call through
2347
# its _translate_error
2348
_translate_error(err, branch=self)
2349
except errors.UnknownSmartMethod, err:
2351
return self._real_branch.get_stacked_on_url()
2352
if response[0] != 'ok':
2353
raise errors.UnexpectedSmartServerResponse(response)
2356
def set_stacked_on_url(self, url):
2357
branch.Branch.set_stacked_on_url(self, url)
2359
self._is_stacked = False
2361
self._is_stacked = True
2363
def _vfs_get_tags_bytes(self):
2365
return self._real_branch._get_tags_bytes()
2367
def _get_tags_bytes(self):
2368
medium = self._client._medium
2369
if medium._is_remote_before((1, 13)):
2370
return self._vfs_get_tags_bytes()
2372
response = self._call('Branch.get_tags_bytes', self._remote_path())
2373
except errors.UnknownSmartMethod:
2374
medium._remember_remote_is_before((1, 13))
2375
return self._vfs_get_tags_bytes()
2378
def _vfs_set_tags_bytes(self, bytes):
2380
return self._real_branch._set_tags_bytes(bytes)
2382
def _set_tags_bytes(self, bytes):
2383
medium = self._client._medium
2384
if medium._is_remote_before((1, 18)):
2385
self._vfs_set_tags_bytes(bytes)
2389
self._remote_path(), self._lock_token, self._repo_lock_token)
2390
response = self._call_with_body_bytes(
2391
'Branch.set_tags_bytes', args, bytes)
2392
except errors.UnknownSmartMethod:
2393
medium._remember_remote_is_before((1, 18))
2394
self._vfs_set_tags_bytes(bytes)
998
2396
def lock_read(self):
2397
"""Lock the branch for read operations.
2399
:return: An object with an unlock method which will release the lock
2402
self.repository.lock_read()
999
2403
if not self._lock_mode:
2404
self._note_lock('r')
1000
2405
self._lock_mode = 'r'
1001
2406
self._lock_count = 1
1002
2407
if self._real_branch is not None:
1003
2408
self._real_branch.lock_read()
1005
2410
self._lock_count += 1
1007
2413
def _remote_lock_write(self, token):
1008
2414
if token is None:
1009
2415
branch_token = repo_token = ''
1011
2417
branch_token = token
1012
repo_token = self.repository.lock_write()
2418
repo_token = self.repository.lock_write().repository_token
1013
2419
self.repository.unlock()
1014
path = self.bzrdir._path_for_remote_call(self._client)
1015
response = self._client.call('Branch.lock_write', path, branch_token,
1017
if response[0] == 'ok':
1018
ok, branch_token, repo_token = response
1019
return branch_token, repo_token
1020
elif response[0] == 'LockContention':
1021
raise errors.LockContention('(remote lock)')
1022
elif response[0] == 'TokenMismatch':
1023
raise errors.TokenMismatch(token, '(remote token)')
1024
elif response[0] == 'UnlockableTransport':
1025
raise errors.UnlockableTransport(self.bzrdir.root_transport)
1026
elif response[0] == 'ReadOnlyError':
1027
raise errors.ReadOnlyError(self)
1028
elif response[0] == 'LockFailed':
1029
raise errors.LockFailed(response[1], response[2])
2420
err_context = {'token': token}
2421
response = self._call(
2422
'Branch.lock_write', self._remote_path(), branch_token,
2423
repo_token or '', **err_context)
2424
if response[0] != 'ok':
1031
2425
raise errors.UnexpectedSmartServerResponse(response)
2426
ok, branch_token, repo_token = response
2427
return branch_token, repo_token
1033
2429
def lock_write(self, token=None):
1034
2430
if not self._lock_mode:
2431
self._note_lock('w')
2432
# Lock the branch and repo in one remote call.
1035
2433
remote_tokens = self._remote_lock_write(token)
1036
2434
self._lock_token, self._repo_lock_token = remote_tokens
1037
assert self._lock_token, 'Remote server did not return a token!'
1038
# TODO: We really, really, really don't want to call _ensure_real
1039
# here, but it's the easiest way to ensure coherency between the
1040
# state of the RemoteBranch and RemoteRepository objects and the
1041
# physical locks. If we don't materialise the real objects here,
1042
# then getting everything in the right state later is complex, so
1043
# for now we just do it the lazy way.
1044
# -- Andrew Bennetts, 2007-02-22.
2435
if not self._lock_token:
2436
raise SmartProtocolError('Remote server did not return a token!')
2437
# Tell the self.repository object that it is locked.
2438
self.repository.lock_write(
2439
self._repo_lock_token, _skip_rpc=True)
1046
2441
if self._real_branch is not None:
1047
self._real_branch.repository.lock_write(
1048
token=self._repo_lock_token)
1050
self._real_branch.lock_write(token=self._lock_token)
1052
self._real_branch.repository.unlock()
2442
self._real_branch.lock_write(token=self._lock_token)
1053
2443
if token is not None:
1054
2444
self._leave_lock = True
1056
# XXX: this case seems to be unreachable; token cannot be None.
1057
2446
self._leave_lock = False
1058
2447
self._lock_mode = 'w'
1059
2448
self._lock_count = 1
1061
2450
raise errors.ReadOnlyTransaction
1063
2452
if token is not None:
1064
# A token was given to lock_write, and we're relocking, so check
1065
# that the given token actually matches the one we already have.
2453
# A token was given to lock_write, and we're relocking, so
2454
# check that the given token actually matches the one we
1066
2456
if token != self._lock_token:
1067
2457
raise errors.TokenMismatch(token, self._lock_token)
1068
2458
self._lock_count += 1
1069
return self._lock_token
2459
# Re-lock the repository too.
2460
self.repository.lock_write(self._repo_lock_token)
2461
return BranchWriteLockResult(self.unlock, self._lock_token or None)
1071
2463
def _unlock(self, branch_token, repo_token):
1072
path = self.bzrdir._path_for_remote_call(self._client)
1073
response = self._client.call('Branch.unlock', path, branch_token,
2464
err_context = {'token': str((branch_token, repo_token))}
2465
response = self._call(
2466
'Branch.unlock', self._remote_path(), branch_token,
2467
repo_token or '', **err_context)
1075
2468
if response == ('ok',):
1077
elif response[0] == 'TokenMismatch':
1078
raise errors.TokenMismatch(
1079
str((branch_token, repo_token)), '(remote tokens)')
1081
raise errors.UnexpectedSmartServerResponse(response)
2470
raise errors.UnexpectedSmartServerResponse(response)
2472
@only_raises(errors.LockNotHeld, errors.LockBroken)
1083
2473
def unlock(self):
1084
self._lock_count -= 1
1085
if not self._lock_count:
1086
self._clear_cached_state()
1087
mode = self._lock_mode
1088
self._lock_mode = None
1089
if self._real_branch is not None:
2475
self._lock_count -= 1
2476
if not self._lock_count:
2477
self._clear_cached_state()
2478
mode = self._lock_mode
2479
self._lock_mode = None
2480
if self._real_branch is not None:
2481
if (not self._leave_lock and mode == 'w' and
2482
self._repo_lock_token):
2483
# If this RemoteBranch will remove the physical lock
2484
# for the repository, make sure the _real_branch
2485
# doesn't do it first. (Because the _real_branch's
2486
# repository is set to be the RemoteRepository.)
2487
self._real_branch.repository.leave_lock_in_place()
2488
self._real_branch.unlock()
2490
# Only write-locked branched need to make a remote method
2491
# call to perform the unlock.
2493
if not self._lock_token:
2494
raise AssertionError('Locked, but no token!')
2495
branch_token = self._lock_token
2496
repo_token = self._repo_lock_token
2497
self._lock_token = None
2498
self._repo_lock_token = None
1090
2499
if not self._leave_lock:
1091
# If this RemoteBranch will remove the physical lock for the
1092
# repository, make sure the _real_branch doesn't do it
1093
# first. (Because the _real_branch's repository is set to
1094
# be the RemoteRepository.)
1095
self._real_branch.repository.leave_lock_in_place()
1096
self._real_branch.unlock()
1098
# Only write-locked branched need to make a remote method call
1099
# to perfom the unlock.
1101
assert self._lock_token, 'Locked, but no token!'
1102
branch_token = self._lock_token
1103
repo_token = self._repo_lock_token
1104
self._lock_token = None
1105
self._repo_lock_token = None
1106
if not self._leave_lock:
1107
self._unlock(branch_token, repo_token)
2500
self._unlock(branch_token, repo_token)
2502
self.repository.unlock()
1109
2504
def break_lock(self):
1110
2505
self._ensure_real()
1111
2506
return self._real_branch.break_lock()
1113
2508
def leave_lock_in_place(self):
2509
if not self._lock_token:
2510
raise NotImplementedError(self.leave_lock_in_place)
1114
2511
self._leave_lock = True
1116
2513
def dont_leave_lock_in_place(self):
2514
if not self._lock_token:
2515
raise NotImplementedError(self.dont_leave_lock_in_place)
1117
2516
self._leave_lock = False
1119
def last_revision_info(self):
1120
"""See Branch.last_revision_info()."""
1121
path = self.bzrdir._path_for_remote_call(self._client)
1122
response = self._client.call('Branch.last_revision_info', path)
1123
assert response[0] == 'ok', 'unexpected response code %s' % (response,)
2519
def get_rev_id(self, revno, history=None):
2521
return _mod_revision.NULL_REVISION
2522
last_revision_info = self.last_revision_info()
2523
ok, result = self.repository.get_rev_id_for_revno(
2524
revno, last_revision_info)
2527
missing_parent = result[1]
2528
# Either the revision named by the server is missing, or its parent
2529
# is. Call get_parent_map to determine which, so that we report a
2531
parent_map = self.repository.get_parent_map([missing_parent])
2532
if missing_parent in parent_map:
2533
missing_parent = parent_map[missing_parent]
2534
raise errors.RevisionNotPresent(missing_parent, self.repository)
2536
def _last_revision_info(self):
2537
response = self._call('Branch.last_revision_info', self._remote_path())
2538
if response[0] != 'ok':
2539
raise SmartProtocolError('unexpected response code %s' % (response,))
1124
2540
revno = int(response[1])
1125
2541
last_revision = response[2]
1126
2542
return (revno, last_revision)
1128
2544
def _gen_revision_history(self):
1129
2545
"""See Branch._gen_revision_history()."""
1130
path = self.bzrdir._path_for_remote_call(self._client)
1131
response = self._client.call_expecting_body(
1132
'Branch.revision_history', path)
1133
assert response[0][0] == 'ok', ('unexpected response code %s'
1135
result = response[1].read_body_bytes().split('\x00')
2546
if self._is_stacked:
2548
return self._real_branch._gen_revision_history()
2549
response_tuple, response_handler = self._call_expecting_body(
2550
'Branch.revision_history', self._remote_path())
2551
if response_tuple[0] != 'ok':
2552
raise errors.UnexpectedSmartServerResponse(response_tuple)
2553
result = response_handler.read_body_bytes().split('\x00')
1136
2554
if result == ['']:
2558
def _remote_path(self):
2559
return self.bzrdir._path_for_remote_call(self._client)
2561
def _set_last_revision_descendant(self, revision_id, other_branch,
2562
allow_diverged=False, allow_overwrite_descendant=False):
2563
# This performs additional work to meet the hook contract; while its
2564
# undesirable, we have to synthesise the revno to call the hook, and
2565
# not calling the hook is worse as it means changes can't be prevented.
2566
# Having calculated this though, we can't just call into
2567
# set_last_revision_info as a simple call, because there is a set_rh
2568
# hook that some folk may still be using.
2569
old_revno, old_revid = self.last_revision_info()
2570
history = self._lefthand_history(revision_id)
2571
self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2572
err_context = {'other_branch': other_branch}
2573
response = self._call('Branch.set_last_revision_ex',
2574
self._remote_path(), self._lock_token, self._repo_lock_token,
2575
revision_id, int(allow_diverged), int(allow_overwrite_descendant),
2577
self._clear_cached_state()
2578
if len(response) != 3 and response[0] != 'ok':
2579
raise errors.UnexpectedSmartServerResponse(response)
2580
new_revno, new_revision_id = response[1:]
2581
self._last_revision_info_cache = new_revno, new_revision_id
2582
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2583
if self._real_branch is not None:
2584
cache = new_revno, new_revision_id
2585
self._real_branch._last_revision_info_cache = cache
2587
def _set_last_revision(self, revision_id):
2588
old_revno, old_revid = self.last_revision_info()
2589
# This performs additional work to meet the hook contract; while its
2590
# undesirable, we have to synthesise the revno to call the hook, and
2591
# not calling the hook is worse as it means changes can't be prevented.
2592
# Having calculated this though, we can't just call into
2593
# set_last_revision_info as a simple call, because there is a set_rh
2594
# hook that some folk may still be using.
2595
history = self._lefthand_history(revision_id)
2596
self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2597
self._clear_cached_state()
2598
response = self._call('Branch.set_last_revision',
2599
self._remote_path(), self._lock_token, self._repo_lock_token,
2601
if response != ('ok',):
2602
raise errors.UnexpectedSmartServerResponse(response)
2603
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
1140
2605
@needs_write_lock
1141
2606
def set_revision_history(self, rev_history):
1142
2607
# Send just the tip revision of the history; the server will generate
1143
2608
# the full history from that. If the revision doesn't exist in this
1144
2609
# branch, NoSuchRevision will be raised.
1145
path = self.bzrdir._path_for_remote_call(self._client)
1146
2610
if rev_history == []:
1147
2611
rev_id = 'null:'
1149
2613
rev_id = rev_history[-1]
1150
self._clear_cached_state()
1151
response = self._client.call('Branch.set_last_revision',
1152
path, self._lock_token, self._repo_lock_token, rev_id)
1153
if response[0] == 'NoSuchRevision':
1154
raise NoSuchRevision(self, rev_id)
1156
assert response == ('ok',), (
1157
'unexpected response code %r' % (response,))
2614
self._set_last_revision(rev_id)
2615
for hook in branch.Branch.hooks['set_rh']:
2616
hook(self, rev_history)
1158
2617
self._cache_revision_history(rev_history)
1160
def get_parent(self):
1162
return self._real_branch.get_parent()
1164
def set_parent(self, url):
1166
return self._real_branch.set_parent(url)
1168
def get_config(self):
1169
return RemoteBranchConfig(self)
1171
def sprout(self, to_bzrdir, revision_id=None):
1172
# Like Branch.sprout, except that it sprouts a branch in the default
1173
# format, because RemoteBranches can't be created at arbitrary URLs.
1174
# XXX: if to_bzrdir is a RemoteBranch, this should perhaps do
1175
# to_bzrdir.create_branch...
1176
result = branch.BranchFormat.get_default_format().initialize(to_bzrdir)
1177
self.copy_content_into(result, revision_id=revision_id)
1178
result.set_parent(self.bzrdir.root_transport.base)
2619
def _get_parent_location(self):
2620
medium = self._client._medium
2621
if medium._is_remote_before((1, 13)):
2622
return self._vfs_get_parent_location()
2624
response = self._call('Branch.get_parent', self._remote_path())
2625
except errors.UnknownSmartMethod:
2626
medium._remember_remote_is_before((1, 13))
2627
return self._vfs_get_parent_location()
2628
if len(response) != 1:
2629
raise errors.UnexpectedSmartServerResponse(response)
2630
parent_location = response[0]
2631
if parent_location == '':
2633
return parent_location
2635
def _vfs_get_parent_location(self):
2637
return self._real_branch._get_parent_location()
2639
def _set_parent_location(self, url):
2640
medium = self._client._medium
2641
if medium._is_remote_before((1, 15)):
2642
return self._vfs_set_parent_location(url)
2644
call_url = url or ''
2645
if type(call_url) is not str:
2646
raise AssertionError('url must be a str or None (%s)' % url)
2647
response = self._call('Branch.set_parent_location',
2648
self._remote_path(), self._lock_token, self._repo_lock_token,
2650
except errors.UnknownSmartMethod:
2651
medium._remember_remote_is_before((1, 15))
2652
return self._vfs_set_parent_location(url)
2654
raise errors.UnexpectedSmartServerResponse(response)
2656
def _vfs_set_parent_location(self, url):
2658
return self._real_branch._set_parent_location(url)
1181
2660
@needs_write_lock
1182
2661
def pull(self, source, overwrite=False, stop_revision=None,
1184
# FIXME: This asks the real branch to run the hooks, which means
1185
# they're called with the wrong target branch parameter.
1186
# The test suite specifically allows this at present but it should be
1187
# fixed. It should get a _override_hook_target branch,
1188
# as push does. -- mbp 20070405
2663
self._clear_cached_state_of_remote_branch_only()
1189
2664
self._ensure_real()
1190
self._real_branch.pull(
2665
return self._real_branch.pull(
1191
2666
source, overwrite=overwrite, stop_revision=stop_revision,
2667
_override_hook_target=self, **kwargs)
1194
2669
@needs_read_lock
1195
2670
def push(self, target, overwrite=False, stop_revision=None):
1201
2676
def is_locked(self):
1202
2677
return self._lock_count >= 1
2680
def revision_id_to_revno(self, revision_id):
2682
return self._real_branch.revision_id_to_revno(revision_id)
1204
2685
def set_last_revision_info(self, revno, revision_id):
1206
self._clear_cached_state()
1207
return self._real_branch.set_last_revision_info(revno, revision_id)
2686
# XXX: These should be returned by the set_last_revision_info verb
2687
old_revno, old_revid = self.last_revision_info()
2688
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2689
revision_id = ensure_null(revision_id)
2691
response = self._call('Branch.set_last_revision_info',
2692
self._remote_path(), self._lock_token, self._repo_lock_token,
2693
str(revno), revision_id)
2694
except errors.UnknownSmartMethod:
2696
self._clear_cached_state_of_remote_branch_only()
2697
self._real_branch.set_last_revision_info(revno, revision_id)
2698
self._last_revision_info_cache = revno, revision_id
2700
if response == ('ok',):
2701
self._clear_cached_state()
2702
self._last_revision_info_cache = revno, revision_id
2703
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2704
# Update the _real_branch's cache too.
2705
if self._real_branch is not None:
2706
cache = self._last_revision_info_cache
2707
self._real_branch._last_revision_info_cache = cache
2709
raise errors.UnexpectedSmartServerResponse(response)
1209
2712
def generate_revision_history(self, revision_id, last_rev=None,
1210
2713
other_branch=None):
1212
return self._real_branch.generate_revision_history(
1213
revision_id, last_rev=last_rev, other_branch=other_branch)
1218
return self._real_branch.tags
2714
medium = self._client._medium
2715
if not medium._is_remote_before((1, 6)):
2716
# Use a smart method for 1.6 and above servers
2718
self._set_last_revision_descendant(revision_id, other_branch,
2719
allow_diverged=True, allow_overwrite_descendant=True)
2721
except errors.UnknownSmartMethod:
2722
medium._remember_remote_is_before((1, 6))
2723
self._clear_cached_state_of_remote_branch_only()
2724
self.set_revision_history(self._lefthand_history(revision_id,
2725
last_rev=last_rev,other_branch=other_branch))
1220
2727
def set_push_location(self, location):
1221
2728
self._ensure_real()
1222
2729
return self._real_branch.set_push_location(location)
1224
def update_revisions(self, other, stop_revision=None):
1226
return self._real_branch.update_revisions(
1227
other, stop_revision=stop_revision)
1230
class RemoteBranchConfig(BranchConfig):
1233
self.branch._ensure_real()
1234
return self.branch._real_branch.get_config().username()
1236
def _get_branch_data_config(self):
1237
self.branch._ensure_real()
1238
if self._branch_data_config is None:
1239
self._branch_data_config = TreeConfig(self.branch._real_branch)
1240
return self._branch_data_config
2732
class RemoteConfig(object):
2733
"""A Config that reads and writes from smart verbs.
2735
It is a low-level object that considers config data to be name/value pairs
2736
that may be associated with a section. Assigning meaning to the these
2737
values is done at higher levels like bzrlib.config.TreeConfig.
2740
def get_option(self, name, section=None, default=None):
2741
"""Return the value associated with a named option.
2743
:param name: The name of the value
2744
:param section: The section the option is in (if any)
2745
:param default: The value to return if the value is not set
2746
:return: The value or default value
2749
configobj = self._get_configobj()
2751
section_obj = configobj
2754
section_obj = configobj[section]
2757
return section_obj.get(name, default)
2758
except errors.UnknownSmartMethod:
2759
return self._vfs_get_option(name, section, default)
2761
def _response_to_configobj(self, response):
2762
if len(response[0]) and response[0][0] != 'ok':
2763
raise errors.UnexpectedSmartServerResponse(response)
2764
lines = response[1].read_body_bytes().splitlines()
2765
return config.ConfigObj(lines, encoding='utf-8')
2768
class RemoteBranchConfig(RemoteConfig):
2769
"""A RemoteConfig for Branches."""
2771
def __init__(self, branch):
2772
self._branch = branch
2774
def _get_configobj(self):
2775
path = self._branch._remote_path()
2776
response = self._branch._client.call_expecting_body(
2777
'Branch.get_config_file', path)
2778
return self._response_to_configobj(response)
2780
def set_option(self, value, name, section=None):
2781
"""Set the value associated with a named option.
2783
:param value: The value to set
2784
:param name: The name of the value to set
2785
:param section: The section the option is in (if any)
2787
medium = self._branch._client._medium
2788
if medium._is_remote_before((1, 14)):
2789
return self._vfs_set_option(value, name, section)
2791
path = self._branch._remote_path()
2792
response = self._branch._client.call('Branch.set_config_option',
2793
path, self._branch._lock_token, self._branch._repo_lock_token,
2794
value.encode('utf8'), name, section or '')
2795
except errors.UnknownSmartMethod:
2796
medium._remember_remote_is_before((1, 14))
2797
return self._vfs_set_option(value, name, section)
2799
raise errors.UnexpectedSmartServerResponse(response)
2801
def _real_object(self):
2802
self._branch._ensure_real()
2803
return self._branch._real_branch
2805
def _vfs_set_option(self, value, name, section=None):
2806
return self._real_object()._get_config().set_option(
2807
value, name, section)
2810
class RemoteBzrDirConfig(RemoteConfig):
2811
"""A RemoteConfig for BzrDirs."""
2813
def __init__(self, bzrdir):
2814
self._bzrdir = bzrdir
2816
def _get_configobj(self):
2817
medium = self._bzrdir._client._medium
2818
verb = 'BzrDir.get_config_file'
2819
if medium._is_remote_before((1, 15)):
2820
raise errors.UnknownSmartMethod(verb)
2821
path = self._bzrdir._path_for_remote_call(self._bzrdir._client)
2822
response = self._bzrdir._call_expecting_body(
2824
return self._response_to_configobj(response)
2826
def _vfs_get_option(self, name, section, default):
2827
return self._real_object()._get_config().get_option(
2828
name, section, default)
2830
def set_option(self, value, name, section=None):
2831
"""Set the value associated with a named option.
2833
:param value: The value to set
2834
:param name: The name of the value to set
2835
:param section: The section the option is in (if any)
2837
return self._real_object()._get_config().set_option(
2838
value, name, section)
2840
def _real_object(self):
2841
self._bzrdir._ensure_real()
2842
return self._bzrdir._real_bzrdir
1243
2846
def _extract_tar(tar, to_dir):
1248
2851
for tarinfo in tar:
1249
2852
tar.extract(tarinfo, to_dir)
2855
def _translate_error(err, **context):
2856
"""Translate an ErrorFromSmartServer into a more useful error.
2858
Possible context keys:
2866
If the error from the server doesn't match a known pattern, then
2867
UnknownErrorFromSmartServer is raised.
2871
return context[name]
2872
except KeyError, key_err:
2873
mutter('Missing key %r in context %r', key_err.args[0], context)
2876
"""Get the path from the context if present, otherwise use first error
2880
return context['path']
2881
except KeyError, key_err:
2883
return err.error_args[0]
2884
except IndexError, idx_err:
2886
'Missing key %r in context %r', key_err.args[0], context)
2889
if err.error_verb == 'IncompatibleRepositories':
2890
raise errors.IncompatibleRepositories(err.error_args[0],
2891
err.error_args[1], err.error_args[2])
2892
elif err.error_verb == 'NoSuchRevision':
2893
raise NoSuchRevision(find('branch'), err.error_args[0])
2894
elif err.error_verb == 'nosuchrevision':
2895
raise NoSuchRevision(find('repository'), err.error_args[0])
2896
elif err.error_verb == 'nobranch':
2897
if len(err.error_args) >= 1:
2898
extra = err.error_args[0]
2901
raise errors.NotBranchError(path=find('bzrdir').root_transport.base,
2903
elif err.error_verb == 'norepository':
2904
raise errors.NoRepositoryPresent(find('bzrdir'))
2905
elif err.error_verb == 'LockContention':
2906
raise errors.LockContention('(remote lock)')
2907
elif err.error_verb == 'UnlockableTransport':
2908
raise errors.UnlockableTransport(find('bzrdir').root_transport)
2909
elif err.error_verb == 'LockFailed':
2910
raise errors.LockFailed(err.error_args[0], err.error_args[1])
2911
elif err.error_verb == 'TokenMismatch':
2912
raise errors.TokenMismatch(find('token'), '(remote token)')
2913
elif err.error_verb == 'Diverged':
2914
raise errors.DivergedBranches(find('branch'), find('other_branch'))
2915
elif err.error_verb == 'TipChangeRejected':
2916
raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
2917
elif err.error_verb == 'UnstackableBranchFormat':
2918
raise errors.UnstackableBranchFormat(*err.error_args)
2919
elif err.error_verb == 'UnstackableRepositoryFormat':
2920
raise errors.UnstackableRepositoryFormat(*err.error_args)
2921
elif err.error_verb == 'NotStacked':
2922
raise errors.NotStacked(branch=find('branch'))
2923
elif err.error_verb == 'PermissionDenied':
2925
if len(err.error_args) >= 2:
2926
extra = err.error_args[1]
2929
raise errors.PermissionDenied(path, extra=extra)
2930
elif err.error_verb == 'ReadError':
2932
raise errors.ReadError(path)
2933
elif err.error_verb == 'NoSuchFile':
2935
raise errors.NoSuchFile(path)
2936
elif err.error_verb == 'FileExists':
2937
raise errors.FileExists(err.error_args[0])
2938
elif err.error_verb == 'DirectoryNotEmpty':
2939
raise errors.DirectoryNotEmpty(err.error_args[0])
2940
elif err.error_verb == 'ShortReadvError':
2941
args = err.error_args
2942
raise errors.ShortReadvError(
2943
args[0], int(args[1]), int(args[2]), int(args[3]))
2944
elif err.error_verb in ('UnicodeEncodeError', 'UnicodeDecodeError'):
2945
encoding = str(err.error_args[0]) # encoding must always be a string
2946
val = err.error_args[1]
2947
start = int(err.error_args[2])
2948
end = int(err.error_args[3])
2949
reason = str(err.error_args[4]) # reason must always be a string
2950
if val.startswith('u:'):
2951
val = val[2:].decode('utf-8')
2952
elif val.startswith('s:'):
2953
val = val[2:].decode('base64')
2954
if err.error_verb == 'UnicodeDecodeError':
2955
raise UnicodeDecodeError(encoding, val, start, end, reason)
2956
elif err.error_verb == 'UnicodeEncodeError':
2957
raise UnicodeEncodeError(encoding, val, start, end, reason)
2958
elif err.error_verb == 'ReadOnlyError':
2959
raise errors.TransportNotPossible('readonly transport')
2960
raise errors.UnknownErrorFromSmartServer(err)
added
removed
bzrlib/remote.py
