13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
# TODO: At some point, handle upgrades by just passing the whole request
18
# across to run on the server.
19
22
from bzrlib import (
30
repository as _mod_repository,
32
revision as _mod_revision,
36
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
32
from bzrlib.branch import BranchReferenceFormat
37
33
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
38
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
34
from bzrlib.decorators import needs_read_lock, needs_write_lock
39
35
from bzrlib.errors import (
41
37
SmartProtocolError,
43
39
from bzrlib.lockable_files import LockableFiles
44
from bzrlib.smart import client, vfs, repository as smart_repo
40
from bzrlib.smart import client, vfs
45
41
from bzrlib.revision import ensure_null, NULL_REVISION
46
from bzrlib.repository import RepositoryWriteLockResult
47
42
from bzrlib.trace import mutter, note, warning
50
class _RpcHelper(object):
51
"""Mixin class that helps with issuing RPCs."""
53
def _call(self, method, *args, **err_context):
55
return self._client.call(method, *args)
56
except errors.ErrorFromSmartServer, err:
57
self._translate_error(err, **err_context)
59
def _call_expecting_body(self, method, *args, **err_context):
61
return self._client.call_expecting_body(method, *args)
62
except errors.ErrorFromSmartServer, err:
63
self._translate_error(err, **err_context)
65
def _call_with_body_bytes(self, method, args, body_bytes, **err_context):
67
return self._client.call_with_body_bytes(method, args, body_bytes)
68
except errors.ErrorFromSmartServer, err:
69
self._translate_error(err, **err_context)
71
def _call_with_body_bytes_expecting_body(self, method, args, body_bytes,
74
return self._client.call_with_body_bytes_expecting_body(
75
method, args, body_bytes)
76
except errors.ErrorFromSmartServer, err:
77
self._translate_error(err, **err_context)
80
def response_tuple_to_repo_format(response):
81
"""Convert a response tuple describing a repository format to a format."""
82
format = RemoteRepositoryFormat()
83
format._rich_root_data = (response[0] == 'yes')
84
format._supports_tree_reference = (response[1] == 'yes')
85
format._supports_external_lookups = (response[2] == 'yes')
86
format._network_name = response[3]
90
45
# Note: RemoteBzrDirFormat is in bzrdir.py
92
class RemoteBzrDir(BzrDir, _RpcHelper):
47
class RemoteBzrDir(BzrDir):
93
48
"""Control directory on a remote server, accessed via bzr:// or similar."""
95
def __init__(self, transport, format, _client=None, _force_probe=False):
50
def __init__(self, transport, _client=None):
96
51
"""Construct a RemoteBzrDir.
98
53
:param _client: Private parameter for testing. Disables probing and the
99
54
use of a real bzrdir.
101
BzrDir.__init__(self, transport, format)
56
BzrDir.__init__(self, transport, RemoteBzrDirFormat())
102
57
# this object holds a delegated bzrdir that uses file-level operations
103
58
# to talk to the other side
104
59
self._real_bzrdir = None
105
self._has_working_tree = None
106
# 1-shot cache for the call pattern 'create_branch; open_branch' - see
107
# create_branch for details.
108
self._next_open_branch_result = None
110
61
if _client is None:
111
62
medium = transport.get_smart_medium()
112
63
self._client = client._SmartClient(medium)
114
65
self._client = _client
121
return '%s(%r)' % (self.__class__.__name__, self._client)
123
def _probe_bzrdir(self):
124
medium = self._client._medium
125
68
path = self._path_for_remote_call(self._client)
126
if medium._is_remote_before((2, 1)):
130
self._rpc_open_2_1(path)
132
except errors.UnknownSmartMethod:
133
medium._remember_remote_is_before((2, 1))
136
def _rpc_open_2_1(self, path):
137
response = self._call('BzrDir.open_2.1', path)
138
if response == ('no',):
139
raise errors.NotBranchError(path=self.root_transport.base)
140
elif response[0] == 'yes':
141
if response[1] == 'yes':
142
self._has_working_tree = True
143
elif response[1] == 'no':
144
self._has_working_tree = False
146
raise errors.UnexpectedSmartServerResponse(response)
148
raise errors.UnexpectedSmartServerResponse(response)
150
def _rpc_open(self, path):
151
response = self._call('BzrDir.open', path)
69
response = self._client.call('BzrDir.open', path)
152
70
if response not in [('yes',), ('no',)]:
153
71
raise errors.UnexpectedSmartServerResponse(response)
154
72
if response == ('no',):
155
raise errors.NotBranchError(path=self.root_transport.base)
73
raise errors.NotBranchError(path=transport.base)
157
75
def _ensure_real(self):
158
76
"""Ensure that there is a _real_bzrdir set.
160
78
Used before calls to self._real_bzrdir.
162
80
if not self._real_bzrdir:
163
if 'hpssvfs' in debug.debug_flags:
165
warning('VFS BzrDir access triggered\n%s',
166
''.join(traceback.format_stack()))
167
81
self._real_bzrdir = BzrDir.open_from_transport(
168
82
self.root_transport, _server_formats=False)
169
self._format._network_name = \
170
self._real_bzrdir._format.network_name()
84
def cloning_metadir(self, stacked=False):
86
return self._real_bzrdir.cloning_metadir(stacked)
172
88
def _translate_error(self, err, **context):
173
89
_translate_error(err, bzrdir=self, **context)
175
def break_lock(self):
176
# Prevent aliasing problems in the next_open_branch_result cache.
177
# See create_branch for rationale.
178
self._next_open_branch_result = None
179
return BzrDir.break_lock(self)
181
def _vfs_cloning_metadir(self, require_stacking=False):
183
return self._real_bzrdir.cloning_metadir(
184
require_stacking=require_stacking)
186
def cloning_metadir(self, require_stacking=False):
187
medium = self._client._medium
188
if medium._is_remote_before((1, 13)):
189
return self._vfs_cloning_metadir(require_stacking=require_stacking)
190
verb = 'BzrDir.cloning_metadir'
195
path = self._path_for_remote_call(self._client)
197
response = self._call(verb, path, stacking)
198
except errors.UnknownSmartMethod:
199
medium._remember_remote_is_before((1, 13))
200
return self._vfs_cloning_metadir(require_stacking=require_stacking)
201
except errors.UnknownErrorFromSmartServer, err:
202
if err.error_tuple != ('BranchReference',):
204
# We need to resolve the branch reference to determine the
205
# cloning_metadir. This causes unnecessary RPCs to open the
206
# referenced branch (and bzrdir, etc) but only when the caller
207
# didn't already resolve the branch reference.
208
referenced_branch = self.open_branch()
209
return referenced_branch.bzrdir.cloning_metadir()
210
if len(response) != 3:
211
raise errors.UnexpectedSmartServerResponse(response)
212
control_name, repo_name, branch_info = response
213
if len(branch_info) != 2:
214
raise errors.UnexpectedSmartServerResponse(response)
215
branch_ref, branch_name = branch_info
216
format = bzrdir.network_format_registry.get(control_name)
218
format.repository_format = repository.network_format_registry.get(
220
if branch_ref == 'ref':
221
# XXX: we need possible_transports here to avoid reopening the
222
# connection to the referenced location
223
ref_bzrdir = BzrDir.open(branch_name)
224
branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
225
format.set_branch_format(branch_format)
226
elif branch_ref == 'branch':
228
format.set_branch_format(
229
branch.network_format_registry.get(branch_name))
231
raise errors.UnexpectedSmartServerResponse(response)
234
91
def create_repository(self, shared=False):
235
# as per meta1 formats - just delegate to the format object which may
237
result = self._format.repository_format.initialize(self, shared)
238
if not isinstance(result, RemoteRepository):
239
return self.open_repository()
93
self._real_bzrdir.create_repository(shared=shared)
94
return self.open_repository()
243
96
def destroy_repository(self):
244
97
"""See BzrDir.destroy_repository"""
245
98
self._ensure_real()
246
99
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
101
def create_branch(self):
103
real_branch = self._real_bzrdir.create_branch()
104
return RemoteBranch(self, self.find_repository(), real_branch)
267
def destroy_branch(self, name=None):
106
def destroy_branch(self):
268
107
"""See BzrDir.destroy_branch"""
269
108
self._ensure_real()
270
self._real_bzrdir.destroy_branch(name=name)
271
self._next_open_branch_result = None
109
self._real_bzrdir.destroy_branch()
273
111
def create_workingtree(self, revision_id=None, from_branch=None):
274
112
raise errors.NotLocalUrl(self.transport.base)
276
def find_branch_format(self, name=None):
114
def find_branch_format(self):
277
115
"""Find the branch 'format' for this bzrdir.
279
117
This might be a synthetic object for e.g. RemoteBranch and SVN.
281
b = self.open_branch(name=name)
119
b = self.open_branch()
284
def get_branch_reference(self, name=None):
122
def get_branch_reference(self):
285
123
"""See BzrDir.get_branch_reference()."""
287
# XXX JRV20100304: Support opening colocated branches
288
raise errors.NoColocatedBranchSupport(self)
289
response = self._get_branch_reference()
290
if response[0] == 'ref':
124
path = self._path_for_remote_call(self._client)
126
response = self._client.call('BzrDir.open_branch', path)
127
except errors.ErrorFromSmartServer, err:
128
self._translate_error(err)
129
if response[0] == 'ok':
130
if response[1] == '':
131
# branch at this location.
134
# a branch reference, use the existing BranchReference logic.
295
def _get_branch_reference(self):
296
path = self._path_for_remote_call(self._client)
297
medium = self._client._medium
299
('BzrDir.open_branchV3', (2, 1)),
300
('BzrDir.open_branchV2', (1, 13)),
301
('BzrDir.open_branch', None),
303
for verb, required_version in candidate_calls:
304
if required_version and medium._is_remote_before(required_version):
307
response = self._call(verb, path)
308
except errors.UnknownSmartMethod:
309
if required_version is None:
311
medium._remember_remote_is_before(required_version)
314
if verb == 'BzrDir.open_branch':
315
if response[0] != 'ok':
316
raise errors.UnexpectedSmartServerResponse(response)
317
if response[1] != '':
318
return ('ref', response[1])
320
return ('branch', '')
321
if response[0] not in ('ref', 'branch'):
322
137
raise errors.UnexpectedSmartServerResponse(response)
325
def _get_tree_branch(self, name=None):
139
def _get_tree_branch(self):
326
140
"""See BzrDir._get_tree_branch()."""
327
return None, self.open_branch(name=name)
141
return None, self.open_branch()
329
def open_branch(self, name=None, unsupported=False,
330
ignore_fallbacks=False):
143
def open_branch(self, _unsupported=False):
332
145
raise NotImplementedError('unsupported flag support not implemented yet.')
333
if self._next_open_branch_result is not None:
334
# See create_branch for details.
335
result = self._next_open_branch_result
336
self._next_open_branch_result = None
338
response = self._get_branch_reference()
339
if response[0] == 'ref':
146
reference_url = self.get_branch_reference()
147
if reference_url is None:
148
# branch at this location.
149
return RemoteBranch(self, self.find_repository())
340
151
# a branch reference, use the existing BranchReference logic.
341
152
format = BranchReferenceFormat()
342
return format.open(self, name=name, _found=True,
343
location=response[1], ignore_fallbacks=ignore_fallbacks)
344
branch_format_name = response[1]
345
if not branch_format_name:
346
branch_format_name = None
347
format = RemoteBranchFormat(network_name=branch_format_name)
348
return RemoteBranch(self, self.find_repository(), format=format,
349
setup_stacking=not ignore_fallbacks, name=name)
351
def _open_repo_v1(self, path):
352
verb = 'BzrDir.find_repository'
353
response = self._call(verb, path)
354
if response[0] != 'ok':
355
raise errors.UnexpectedSmartServerResponse(response)
356
# servers that only support the v1 method don't support external
359
repo = self._real_bzrdir.open_repository()
360
response = response + ('no', repo._format.network_name())
361
return response, repo
363
def _open_repo_v2(self, path):
153
return format.open(self, _found=True, location=reference_url)
155
def open_repository(self):
156
path = self._path_for_remote_call(self._client)
364
157
verb = 'BzrDir.find_repositoryV2'
365
response = self._call(verb, path)
366
if response[0] != 'ok':
367
raise errors.UnexpectedSmartServerResponse(response)
369
repo = self._real_bzrdir.open_repository()
370
response = response + (repo._format.network_name(),)
371
return response, repo
373
def _open_repo_v3(self, path):
374
verb = 'BzrDir.find_repositoryV3'
375
medium = self._client._medium
376
if medium._is_remote_before((1, 13)):
377
raise errors.UnknownSmartMethod(verb)
379
response = self._call(verb, path)
380
except errors.UnknownSmartMethod:
381
medium._remember_remote_is_before((1, 13))
383
if response[0] != 'ok':
384
raise errors.UnexpectedSmartServerResponse(response)
385
return response, None
387
def open_repository(self):
388
path = self._path_for_remote_call(self._client)
390
for probe in [self._open_repo_v3, self._open_repo_v2,
393
response, real_repo = probe(path)
160
response = self._client.call(verb, path)
395
161
except errors.UnknownSmartMethod:
398
raise errors.UnknownSmartMethod('BzrDir.find_repository{3,2,}')
162
verb = 'BzrDir.find_repository'
163
response = self._client.call(verb, path)
164
except errors.ErrorFromSmartServer, err:
165
self._translate_error(err)
399
166
if response[0] != 'ok':
400
167
raise errors.UnexpectedSmartServerResponse(response)
401
if len(response) != 6:
168
if verb == 'BzrDir.find_repository':
169
# servers that don't support the V2 method don't support external
171
response = response + ('no', )
172
if not (len(response) == 5):
402
173
raise SmartProtocolError('incorrect response length %s' % (response,))
403
174
if response[1] == '':
404
# repo is at this dir.
405
format = response_tuple_to_repo_format(response[2:])
175
format = RemoteRepositoryFormat()
176
format.rich_root_data = (response[2] == 'yes')
177
format.supports_tree_reference = (response[3] == 'yes')
178
# No wire format to check this yet.
179
format.supports_external_lookups = (response[4] == 'yes')
406
180
# Used to support creating a real format instance when needed.
407
181
format._creating_bzrdir = self
408
remote_repo = RemoteRepository(self, format)
409
format._creating_repo = remote_repo
410
if real_repo is not None:
411
remote_repo._set_real_repository(real_repo)
182
return RemoteRepository(self, format)
414
184
raise errors.NoRepositoryPresent(self)
416
def has_workingtree(self):
417
if self._has_working_tree is None:
419
self._has_working_tree = self._real_bzrdir.has_workingtree()
420
return self._has_working_tree
422
186
def open_workingtree(self, recommend_upgrade=True):
423
if self.has_workingtree():
188
if self._real_bzrdir.has_workingtree():
424
189
raise errors.NotLocalUrl(self.root_transport)
426
191
raise errors.NoWorkingTree(self.root_transport.base)
473
236
the attributes rich_root_data and supports_tree_reference are set
474
237
on a per instance basis, and are not set (and should not be) at
477
:ivar _custom_format: If set, a specific concrete repository format that
478
will be used when initializing a repository with this
479
RemoteRepositoryFormat.
480
:ivar _creating_repo: If set, the repository object that this
481
RemoteRepositoryFormat was created for: it can be called into
482
to obtain data like the network name.
485
241
_matchingbzrdir = RemoteBzrDirFormat()
488
repository.RepositoryFormat.__init__(self)
489
self._custom_format = None
490
self._network_name = None
491
self._creating_bzrdir = None
492
self._supports_chks = None
493
self._supports_external_lookups = None
494
self._supports_tree_reference = None
495
self._rich_root_data = None
498
return "%s(_network_name=%r)" % (self.__class__.__name__,
502
def fast_deltas(self):
504
return self._custom_format.fast_deltas
507
def rich_root_data(self):
508
if self._rich_root_data is None:
510
self._rich_root_data = self._custom_format.rich_root_data
511
return self._rich_root_data
514
def supports_chks(self):
515
if self._supports_chks is None:
517
self._supports_chks = self._custom_format.supports_chks
518
return self._supports_chks
521
def supports_external_lookups(self):
522
if self._supports_external_lookups is None:
524
self._supports_external_lookups = \
525
self._custom_format.supports_external_lookups
526
return self._supports_external_lookups
529
def supports_tree_reference(self):
530
if self._supports_tree_reference is None:
532
self._supports_tree_reference = \
533
self._custom_format.supports_tree_reference
534
return self._supports_tree_reference
536
def _vfs_initialize(self, a_bzrdir, shared):
537
"""Helper for common code in initialize."""
538
if self._custom_format:
539
# Custom format requested
540
result = self._custom_format.initialize(a_bzrdir, shared=shared)
541
elif self._creating_bzrdir is not None:
542
# Use the format that the repository we were created to back
243
def initialize(self, a_bzrdir, shared=False):
244
if not isinstance(a_bzrdir, RemoteBzrDir):
544
245
prior_repo = self._creating_bzrdir.open_repository()
545
246
prior_repo._ensure_real()
546
result = prior_repo._real_repository._format.initialize(
247
return prior_repo._real_repository._format.initialize(
547
248
a_bzrdir, shared=shared)
549
# assume that a_bzr is a RemoteBzrDir but the smart server didn't
550
# support remote initialization.
551
# We delegate to a real object at this point (as RemoteBzrDir
552
# delegate to the repository format which would lead to infinite
553
# recursion if we just called a_bzrdir.create_repository.
554
a_bzrdir._ensure_real()
555
result = a_bzrdir._real_bzrdir.create_repository(shared=shared)
556
if not isinstance(result, RemoteRepository):
557
return self.open(a_bzrdir)
561
def initialize(self, a_bzrdir, shared=False):
562
# Being asked to create on a non RemoteBzrDir:
563
if not isinstance(a_bzrdir, RemoteBzrDir):
564
return self._vfs_initialize(a_bzrdir, shared)
565
medium = a_bzrdir._client._medium
566
if medium._is_remote_before((1, 13)):
567
return self._vfs_initialize(a_bzrdir, shared)
568
# Creating on a remote bzr dir.
569
# 1) get the network name to use.
570
if self._custom_format:
571
network_name = self._custom_format.network_name()
572
elif self._network_name:
573
network_name = self._network_name
575
# Select the current bzrlib default and ask for that.
576
reference_bzrdir_format = bzrdir.format_registry.get('default')()
577
reference_format = reference_bzrdir_format.repository_format
578
network_name = reference_format.network_name()
579
# 2) try direct creation via RPC
580
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
581
verb = 'BzrDir.create_repository'
587
response = a_bzrdir._call(verb, path, network_name, shared_str)
588
except errors.UnknownSmartMethod:
589
# Fallback - use vfs methods
590
medium._remember_remote_is_before((1, 13))
591
return self._vfs_initialize(a_bzrdir, shared)
593
# Turn the response into a RemoteRepository object.
594
format = response_tuple_to_repo_format(response[1:])
595
# Used to support creating a real format instance when needed.
596
format._creating_bzrdir = a_bzrdir
597
remote_repo = RemoteRepository(a_bzrdir, format)
598
format._creating_repo = remote_repo
249
return a_bzrdir.create_repository(shared=shared)
601
251
def open(self, a_bzrdir):
602
252
if not isinstance(a_bzrdir, RemoteBzrDir):
603
253
raise AssertionError('%r is not a RemoteBzrDir' % (a_bzrdir,))
604
254
return a_bzrdir.open_repository()
606
def _ensure_real(self):
607
if self._custom_format is None:
608
self._custom_format = repository.network_format_registry.get(
612
def _fetch_order(self):
614
return self._custom_format._fetch_order
617
def _fetch_uses_deltas(self):
619
return self._custom_format._fetch_uses_deltas
622
def _fetch_reconcile(self):
624
return self._custom_format._fetch_reconcile
626
256
def get_format_description(self):
628
return 'Remote: ' + self._custom_format.get_format_description()
257
return 'bzr remote repository'
630
259
def __eq__(self, other):
631
return self.__class__ is other.__class__
633
def network_name(self):
634
if self._network_name:
635
return self._network_name
636
self._creating_repo._ensure_real()
637
return self._creating_repo._real_repository._format.network_name()
640
def pack_compresses(self):
642
return self._custom_format.pack_compresses
645
def _serializer(self):
647
return self._custom_format._serializer
650
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
651
bzrdir.ControlComponent):
260
return self.__class__ == other.__class__
262
def check_conversion_target(self, target_format):
263
if self.rich_root_data and not target_format.rich_root_data:
264
raise errors.BadConversionTarget(
265
'Does not support rich root data.', target_format)
266
if (self.supports_tree_reference and
267
not getattr(target_format, 'supports_tree_reference', False)):
268
raise errors.BadConversionTarget(
269
'Does not support nested trees', target_format)
272
class RemoteRepository(object):
652
273
"""Repository accessed over rpc.
654
275
For the moment most operations are performed using local transport-backed
748
344
self._ensure_real()
749
345
return self._real_repository.commit_write_group()
751
def resume_write_group(self, tokens):
753
return self._real_repository.resume_write_group(tokens)
755
def suspend_write_group(self):
757
return self._real_repository.suspend_write_group()
759
def get_missing_parent_inventories(self, check_for_missing_texts=True):
761
return self._real_repository.get_missing_parent_inventories(
762
check_for_missing_texts=check_for_missing_texts)
764
def _get_rev_id_for_revno_vfs(self, revno, known_pair):
766
return self._real_repository.get_rev_id_for_revno(
769
def get_rev_id_for_revno(self, revno, known_pair):
770
"""See Repository.get_rev_id_for_revno."""
771
path = self.bzrdir._path_for_remote_call(self._client)
773
if self._client._medium._is_remote_before((1, 17)):
774
return self._get_rev_id_for_revno_vfs(revno, known_pair)
775
response = self._call(
776
'Repository.get_rev_id_for_revno', path, revno, known_pair)
777
except errors.UnknownSmartMethod:
778
self._client._medium._remember_remote_is_before((1, 17))
779
return self._get_rev_id_for_revno_vfs(revno, known_pair)
780
if response[0] == 'ok':
781
return True, response[1]
782
elif response[0] == 'history-incomplete':
783
known_pair = response[1:3]
784
for fallback in self._fallback_repositories:
785
found, result = fallback.get_rev_id_for_revno(revno, known_pair)
790
# Not found in any fallbacks
791
return False, known_pair
793
raise errors.UnexpectedSmartServerResponse(response)
795
347
def _ensure_real(self):
796
348
"""Ensure that there is a _real_repository set.
798
350
Used before calls to self._real_repository.
800
Note that _ensure_real causes many roundtrips to the server which are
801
not desirable, and prevents the use of smart one-roundtrip RPC's to
802
perform complex operations (such as accessing parent data, streaming
803
revisions etc). Adding calls to _ensure_real should only be done when
804
bringing up new functionality, adding fallbacks for smart methods that
805
require a fallback path, and never to replace an existing smart method
806
invocation. If in doubt chat to the bzr network team.
808
352
if self._real_repository is None:
809
if 'hpssvfs' in debug.debug_flags:
811
warning('VFS Repository access triggered\n%s',
812
''.join(traceback.format_stack()))
813
self._unstacked_provider.missing_keys.clear()
814
353
self.bzrdir._ensure_real()
815
354
self._set_real_repository(
816
355
self.bzrdir._real_bzrdir.open_repository())
865
412
for line in lines:
866
413
d = tuple(line.split())
867
414
revision_graph[d[0]] = d[1:]
869
416
return revision_graph
872
"""See Repository._get_sink()."""
873
return RemoteStreamSink(self)
875
def _get_source(self, to_format):
876
"""Return a source for streaming from this repository."""
877
return RemoteStreamSource(self, to_format)
880
418
def has_revision(self, revision_id):
881
"""True if this repository has a copy of the revision."""
882
# Copy of bzrlib.repository.Repository.has_revision
883
return revision_id in self.has_revisions((revision_id,))
419
"""See Repository.has_revision()."""
420
if revision_id == NULL_REVISION:
421
# The null revision is always present.
423
path = self.bzrdir._path_for_remote_call(self._client)
424
response = self._client.call(
425
'Repository.has_revision', path, revision_id)
426
if response[0] not in ('yes', 'no'):
427
raise errors.UnexpectedSmartServerResponse(response)
428
return response[0] == 'yes'
886
430
def has_revisions(self, revision_ids):
887
"""Probe to find out the presence of multiple revisions.
889
:param revision_ids: An iterable of revision_ids.
890
:return: A set of the revision_ids that were present.
892
# Copy of bzrlib.repository.Repository.has_revisions
893
parent_map = self.get_parent_map(revision_ids)
894
result = set(parent_map)
895
if _mod_revision.NULL_REVISION in revision_ids:
896
result.add(_mod_revision.NULL_REVISION)
431
"""See Repository.has_revisions()."""
433
for revision_id in revision_ids:
434
if self.has_revision(revision_id):
435
result.add(revision_id)
899
def _has_same_fallbacks(self, other_repo):
900
"""Returns true if the repositories have the same fallbacks."""
901
# XXX: copied from Repository; it should be unified into a base class
902
# <https://bugs.edge.launchpad.net/bzr/+bug/401622>
903
my_fb = self._fallback_repositories
904
other_fb = other_repo._fallback_repositories
905
if len(my_fb) != len(other_fb):
907
for f, g in zip(my_fb, other_fb):
908
if not f.has_same_location(g):
912
438
def has_same_location(self, other):
913
# TODO: Move to RepositoryBase and unify with the regular Repository
914
# one; unfortunately the tests rely on slightly different behaviour at
915
# present -- mbp 20090710
916
return (self.__class__ is other.__class__ and
439
return (self.__class__ == other.__class__ and
917
440
self.bzrdir.transport.base == other.bzrdir.transport.base)
919
442
def get_graph(self, other_repository=None):
920
443
"""Return the graph for this repository format"""
921
parents_provider = self._make_parents_provider(other_repository)
444
parents_provider = self
445
if (other_repository is not None and
446
other_repository.bzrdir.transport.base !=
447
self.bzrdir.transport.base):
448
parents_provider = graph._StackedParentsProvider(
449
[parents_provider, other_repository._make_parents_provider()])
922
450
return graph.Graph(parents_provider)
925
def get_known_graph_ancestry(self, revision_ids):
926
"""Return the known graph for a set of revision ids and their ancestors.
928
st = static_tuple.StaticTuple
929
revision_keys = [st(r_id).intern() for r_id in revision_ids]
930
known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
931
return graph.GraphThunkIdsToKeys(known_graph)
933
452
def gather_stats(self, revid=None, committers=None):
934
453
"""See Repository.gather_stats()."""
935
454
path = self.bzrdir._path_for_remote_call(self._client)
1236
713
def add_fallback_repository(self, repository):
1237
714
"""Add a repository to use for looking up data not held locally.
1239
716
:param repository: A repository.
1241
718
if not self._format.supports_external_lookups:
1242
raise errors.UnstackableRepositoryFormat(
1243
self._format.network_name(), self.base)
719
raise errors.UnstackableRepositoryFormat(self._format, self.base)
1244
720
# We need to accumulate additional repositories here, to pass them in
1245
721
# on various RPC's.
1247
if self.is_locked():
1248
# We will call fallback.unlock() when we transition to the unlocked
1249
# state, so always add a lock here. If a caller passes us a locked
1250
# repository, they are responsible for unlocking it later.
1251
repository.lock_read()
1252
self._check_fallback_repository(repository)
1253
722
self._fallback_repositories.append(repository)
1254
# If self._real_repository was parameterised already (e.g. because a
1255
# _real_branch had its get_stacked_on_url method called), then the
1256
# repository to be added may already be in the _real_repositories list.
1257
if self._real_repository is not None:
1258
fallback_locations = [repo.user_url for repo in
1259
self._real_repository._fallback_repositories]
1260
if repository.user_url not in fallback_locations:
1261
self._real_repository.add_fallback_repository(repository)
1263
def _check_fallback_repository(self, repository):
1264
"""Check that this repository can fallback to repository safely.
1266
Raise an error if not.
1268
:param repository: A repository to fallback to.
1270
return _mod_repository.InterRepository._assert_same_model(
1273
724
def add_inventory(self, revid, inv, parents):
1274
725
self._ensure_real()
1275
726
return self._real_repository.add_inventory(revid, inv, parents)
1277
def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1278
parents, basis_inv=None, propagate_caches=False):
1280
return self._real_repository.add_inventory_by_delta(basis_revision_id,
1281
delta, new_revision_id, parents, basis_inv=basis_inv,
1282
propagate_caches=propagate_caches)
1284
728
def add_revision(self, rev_id, rev, inv=None, config=None):
1285
729
self._ensure_real()
1286
730
return self._real_repository.add_revision(
1396
811
self._ensure_real()
1397
812
return self._real_repository._get_versioned_file_checker(
1398
813
revisions, revision_versions_cache)
1400
815
def iter_files_bytes(self, desired_files):
1401
816
"""See Repository.iter_file_bytes.
1403
818
self._ensure_real()
1404
819
return self._real_repository.iter_files_bytes(desired_files)
1406
def get_parent_map(self, revision_ids):
822
def _fetch_order(self):
823
"""Decorate the real repository for now.
825
In the long term getting this back from the remote repository as part
826
of open would be more efficient.
829
return self._real_repository._fetch_order
832
def _fetch_uses_deltas(self):
833
"""Decorate the real repository for now.
835
In the long term getting this back from the remote repository as part
836
of open would be more efficient.
839
return self._real_repository._fetch_uses_deltas
842
def _fetch_reconcile(self):
843
"""Decorate the real repository for now.
845
In the long term getting this back from the remote repository as part
846
of open would be more efficient.
849
return self._real_repository._fetch_reconcile
851
def get_parent_map(self, keys):
1407
852
"""See bzrlib.Graph.get_parent_map()."""
1408
return self._make_parents_provider().get_parent_map(revision_ids)
853
# Hack to build up the caching logic.
854
ancestry = self._parents_map
856
# Repository is not locked, so there's no cache.
857
missing_revisions = set(keys)
860
missing_revisions = set(key for key in keys if key not in ancestry)
861
if missing_revisions:
862
parent_map = self._get_parent_map(missing_revisions)
863
if 'hpss' in debug.debug_flags:
864
mutter('retransmitted revisions: %d of %d',
865
len(set(ancestry).intersection(parent_map)),
867
ancestry.update(parent_map)
868
present_keys = [k for k in keys if k in ancestry]
869
if 'hpss' in debug.debug_flags:
870
if self._requested_parents is not None and len(ancestry) != 0:
871
self._requested_parents.update(present_keys)
872
mutter('Current RemoteRepository graph hit rate: %d%%',
873
100.0 * len(self._requested_parents) / len(ancestry))
874
return dict((k, ancestry[k]) for k in present_keys)
1410
def _get_parent_map_rpc(self, keys):
876
def _get_parent_map(self, keys):
1411
877
"""Helper for get_parent_map that performs the RPC."""
1412
878
medium = self._client._medium
1413
879
if medium._is_remote_before((1, 2)):
1414
880
# We already found out that the server can't understand
1415
881
# Repository.get_parent_map requests, so just fetch the whole
1418
# Note that this reads the whole graph, when only some keys are
1419
# wanted. On this old server there's no way (?) to get them all
1420
# in one go, and the user probably will have seen a warning about
1421
# the server being old anyhow.
1422
rg = self._get_revision_graph(None)
1423
# There is an API discrepancy between get_parent_map and
883
# XXX: Note that this will issue a deprecation warning. This is ok
884
# :- its because we're working with a deprecated server anyway, and
885
# the user will almost certainly have seen a warning about the
886
# server version already.
887
rg = self.get_revision_graph()
888
# There is an api discrepency between get_parent_map and
1424
889
# get_revision_graph. Specifically, a "key:()" pair in
1425
890
# get_revision_graph just means a node has no parents. For
1426
891
# "get_parent_map" it means the node is a ghost. So fix up the
1751
1182
:param recipe: A search recipe (start, stop, count).
1752
1183
:return: Serialised bytes.
1754
start_keys = ' '.join(recipe[1])
1755
stop_keys = ' '.join(recipe[2])
1756
count = str(recipe[3])
1185
start_keys = ' '.join(recipe[0])
1186
stop_keys = ' '.join(recipe[1])
1187
count = str(recipe[2])
1757
1188
return '\n'.join((start_keys, stop_keys, count))
1759
def _serialise_search_result(self, search_result):
1760
if isinstance(search_result, graph.PendingAncestryResult):
1761
parts = ['ancestry-of']
1762
parts.extend(search_result.heads)
1764
recipe = search_result.get_recipe()
1765
parts = [recipe[0], self._serialise_search_recipe(recipe)]
1766
return '\n'.join(parts)
1769
path = self.bzrdir._path_for_remote_call(self._client)
1771
response = self._call('PackRepository.autopack', path)
1772
except errors.UnknownSmartMethod:
1774
self._real_repository._pack_collection.autopack()
1777
if response[0] != 'ok':
1778
raise errors.UnexpectedSmartServerResponse(response)
1781
class RemoteStreamSink(repository.StreamSink):
1783
def _insert_real(self, stream, src_format, resume_tokens):
1784
self.target_repo._ensure_real()
1785
sink = self.target_repo._real_repository._get_sink()
1786
result = sink.insert_stream(stream, src_format, resume_tokens)
1788
self.target_repo.autopack()
1791
def insert_stream(self, stream, src_format, resume_tokens):
1792
target = self.target_repo
1793
target._unstacked_provider.missing_keys.clear()
1794
candidate_calls = [('Repository.insert_stream_1.19', (1, 19))]
1795
if target._lock_token:
1796
candidate_calls.append(('Repository.insert_stream_locked', (1, 14)))
1797
lock_args = (target._lock_token or '',)
1799
candidate_calls.append(('Repository.insert_stream', (1, 13)))
1801
client = target._client
1802
medium = client._medium
1803
path = target.bzrdir._path_for_remote_call(client)
1804
# Probe for the verb to use with an empty stream before sending the
1805
# real stream to it. We do this both to avoid the risk of sending a
1806
# large request that is then rejected, and because we don't want to
1807
# implement a way to buffer, rewind, or restart the stream.
1809
for verb, required_version in candidate_calls:
1810
if medium._is_remote_before(required_version):
1813
# We've already done the probing (and set _is_remote_before) on
1814
# a previous insert.
1817
byte_stream = smart_repo._stream_to_byte_stream([], src_format)
1819
response = client.call_with_body_stream(
1820
(verb, path, '') + lock_args, byte_stream)
1821
except errors.UnknownSmartMethod:
1822
medium._remember_remote_is_before(required_version)
1828
return self._insert_real(stream, src_format, resume_tokens)
1829
self._last_inv_record = None
1830
self._last_substream = None
1831
if required_version < (1, 19):
1832
# Remote side doesn't support inventory deltas. Wrap the stream to
1833
# make sure we don't send any. If the stream contains inventory
1834
# deltas we'll interrupt the smart insert_stream request and
1836
stream = self._stop_stream_if_inventory_delta(stream)
1837
byte_stream = smart_repo._stream_to_byte_stream(
1839
resume_tokens = ' '.join(resume_tokens)
1840
response = client.call_with_body_stream(
1841
(verb, path, resume_tokens) + lock_args, byte_stream)
1842
if response[0][0] not in ('ok', 'missing-basis'):
1843
raise errors.UnexpectedSmartServerResponse(response)
1844
if self._last_substream is not None:
1845
# The stream included an inventory-delta record, but the remote
1846
# side isn't new enough to support them. So we need to send the
1847
# rest of the stream via VFS.
1848
self.target_repo.refresh_data()
1849
return self._resume_stream_with_vfs(response, src_format)
1850
if response[0][0] == 'missing-basis':
1851
tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1852
resume_tokens = tokens
1853
return resume_tokens, set(missing_keys)
1855
self.target_repo.refresh_data()
1858
def _resume_stream_with_vfs(self, response, src_format):
1859
"""Resume sending a stream via VFS, first resending the record and
1860
substream that couldn't be sent via an insert_stream verb.
1862
if response[0][0] == 'missing-basis':
1863
tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1864
# Ignore missing_keys, we haven't finished inserting yet
1867
def resume_substream():
1868
# Yield the substream that was interrupted.
1869
for record in self._last_substream:
1871
self._last_substream = None
1872
def resume_stream():
1873
# Finish sending the interrupted substream
1874
yield ('inventory-deltas', resume_substream())
1875
# Then simply continue sending the rest of the stream.
1876
for substream_kind, substream in self._last_stream:
1877
yield substream_kind, substream
1878
return self._insert_real(resume_stream(), src_format, tokens)
1880
def _stop_stream_if_inventory_delta(self, stream):
1881
"""Normally this just lets the original stream pass-through unchanged.
1883
However if any 'inventory-deltas' substream occurs it will stop
1884
streaming, and store the interrupted substream and stream in
1885
self._last_substream and self._last_stream so that the stream can be
1886
resumed by _resume_stream_with_vfs.
1889
stream_iter = iter(stream)
1890
for substream_kind, substream in stream_iter:
1891
if substream_kind == 'inventory-deltas':
1892
self._last_substream = substream
1893
self._last_stream = stream_iter
1896
yield substream_kind, substream
1899
class RemoteStreamSource(repository.StreamSource):
1900
"""Stream data from a remote server."""
1902
def get_stream(self, search):
1903
if (self.from_repository._fallback_repositories and
1904
self.to_format._fetch_order == 'topological'):
1905
return self._real_stream(self.from_repository, search)
1908
repos = [self.from_repository]
1914
repos.extend(repo._fallback_repositories)
1915
sources.append(repo)
1916
return self.missing_parents_chain(search, sources)
1918
def get_stream_for_missing_keys(self, missing_keys):
1919
self.from_repository._ensure_real()
1920
real_repo = self.from_repository._real_repository
1921
real_source = real_repo._get_source(self.to_format)
1922
return real_source.get_stream_for_missing_keys(missing_keys)
1924
def _real_stream(self, repo, search):
1925
"""Get a stream for search from repo.
1927
This never called RemoteStreamSource.get_stream, and is a heler
1928
for RemoteStreamSource._get_stream to allow getting a stream
1929
reliably whether fallback back because of old servers or trying
1930
to stream from a non-RemoteRepository (which the stacked support
1933
source = repo._get_source(self.to_format)
1934
if isinstance(source, RemoteStreamSource):
1936
source = repo._real_repository._get_source(self.to_format)
1937
return source.get_stream(search)
1939
def _get_stream(self, repo, search):
1940
"""Core worker to get a stream from repo for search.
1942
This is used by both get_stream and the stacking support logic. It
1943
deliberately gets a stream for repo which does not need to be
1944
self.from_repository. In the event that repo is not Remote, or
1945
cannot do a smart stream, a fallback is made to the generic
1946
repository._get_stream() interface, via self._real_stream.
1948
In the event of stacking, streams from _get_stream will not
1949
contain all the data for search - this is normal (see get_stream).
1951
:param repo: A repository.
1952
:param search: A search.
1954
# Fallbacks may be non-smart
1955
if not isinstance(repo, RemoteRepository):
1956
return self._real_stream(repo, search)
1957
client = repo._client
1958
medium = client._medium
1959
path = repo.bzrdir._path_for_remote_call(client)
1960
search_bytes = repo._serialise_search_result(search)
1961
args = (path, self.to_format.network_name())
1963
('Repository.get_stream_1.19', (1, 19)),
1964
('Repository.get_stream', (1, 13))]
1966
for verb, version in candidate_verbs:
1967
if medium._is_remote_before(version):
1970
response = repo._call_with_body_bytes_expecting_body(
1971
verb, args, search_bytes)
1972
except errors.UnknownSmartMethod:
1973
medium._remember_remote_is_before(version)
1975
response_tuple, response_handler = response
1979
return self._real_stream(repo, search)
1980
if response_tuple[0] != 'ok':
1981
raise errors.UnexpectedSmartServerResponse(response_tuple)
1982
byte_stream = response_handler.read_streamed_body()
1983
src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
1984
if src_format.network_name() != repo._format.network_name():
1985
raise AssertionError(
1986
"Mismatched RemoteRepository and stream src %r, %r" % (
1987
src_format.network_name(), repo._format.network_name()))
1990
def missing_parents_chain(self, search, sources):
1991
"""Chain multiple streams together to handle stacking.
1993
:param search: The overall search to satisfy with streams.
1994
:param sources: A list of Repository objects to query.
1996
self.from_serialiser = self.from_repository._format._serializer
1997
self.seen_revs = set()
1998
self.referenced_revs = set()
1999
# If there are heads in the search, or the key count is > 0, we are not
2001
while not search.is_empty() and len(sources) > 1:
2002
source = sources.pop(0)
2003
stream = self._get_stream(source, search)
2004
for kind, substream in stream:
2005
if kind != 'revisions':
2006
yield kind, substream
2008
yield kind, self.missing_parents_rev_handler(substream)
2009
search = search.refine(self.seen_revs, self.referenced_revs)
2010
self.seen_revs = set()
2011
self.referenced_revs = set()
2012
if not search.is_empty():
2013
for kind, stream in self._get_stream(sources[0], search):
2016
def missing_parents_rev_handler(self, substream):
2017
for content in substream:
2018
revision_bytes = content.get_bytes_as('fulltext')
2019
revision = self.from_serialiser.read_revision_from_string(
2021
self.seen_revs.add(content.key[-1])
2022
self.referenced_revs.update(revision.parent_ids)
2026
1191
class RemoteBranchLockableFiles(LockableFiles):
2027
1192
"""A 'LockableFiles' implementation that talks to a smart server.
2029
1194
This is not a public interface class.
2046
1211
class RemoteBranchFormat(branch.BranchFormat):
2048
def __init__(self, network_name=None):
2049
super(RemoteBranchFormat, self).__init__()
2050
self._matchingbzrdir = RemoteBzrDirFormat()
2051
self._matchingbzrdir.set_branch_format(self)
2052
self._custom_format = None
2053
self._network_name = network_name
2055
1213
def __eq__(self, other):
2056
return (isinstance(other, RemoteBranchFormat) and
1214
return (isinstance(other, RemoteBranchFormat) and
2057
1215
self.__dict__ == other.__dict__)
2059
def _ensure_real(self):
2060
if self._custom_format is None:
2061
self._custom_format = branch.network_format_registry.get(
2064
1217
def get_format_description(self):
2066
return 'Remote: ' + self._custom_format.get_format_description()
2068
def network_name(self):
2069
return self._network_name
2071
def open(self, a_bzrdir, name=None, ignore_fallbacks=False):
2072
return a_bzrdir.open_branch(name=name,
2073
ignore_fallbacks=ignore_fallbacks)
2075
def _vfs_initialize(self, a_bzrdir, name):
2076
# Initialisation when using a local bzrdir object, or a non-vfs init
2077
# method is not available on the server.
2078
# self._custom_format is always set - the start of initialize ensures
2080
if isinstance(a_bzrdir, RemoteBzrDir):
2081
a_bzrdir._ensure_real()
2082
result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2085
# We assume the bzrdir is parameterised; it may not be.
2086
result = self._custom_format.initialize(a_bzrdir, name)
2087
if (isinstance(a_bzrdir, RemoteBzrDir) and
2088
not isinstance(result, RemoteBranch)):
2089
result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2093
def initialize(self, a_bzrdir, name=None):
2094
# 1) get the network name to use.
2095
if self._custom_format:
2096
network_name = self._custom_format.network_name()
2098
# Select the current bzrlib default and ask for that.
2099
reference_bzrdir_format = bzrdir.format_registry.get('default')()
2100
reference_format = reference_bzrdir_format.get_branch_format()
2101
self._custom_format = reference_format
2102
network_name = reference_format.network_name()
2103
# Being asked to create on a non RemoteBzrDir:
2104
if not isinstance(a_bzrdir, RemoteBzrDir):
2105
return self._vfs_initialize(a_bzrdir, name=name)
2106
medium = a_bzrdir._client._medium
2107
if medium._is_remote_before((1, 13)):
2108
return self._vfs_initialize(a_bzrdir, name=name)
2109
# Creating on a remote bzr dir.
2110
# 2) try direct creation via RPC
2111
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2112
if name is not None:
2113
# XXX JRV20100304: Support creating colocated branches
2114
raise errors.NoColocatedBranchSupport(self)
2115
verb = 'BzrDir.create_branch'
2117
response = a_bzrdir._call(verb, path, network_name)
2118
except errors.UnknownSmartMethod:
2119
# Fallback - use vfs methods
2120
medium._remember_remote_is_before((1, 13))
2121
return self._vfs_initialize(a_bzrdir, name=name)
2122
if response[0] != 'ok':
2123
raise errors.UnexpectedSmartServerResponse(response)
2124
# Turn the response into a RemoteRepository object.
2125
format = RemoteBranchFormat(network_name=response[1])
2126
repo_format = response_tuple_to_repo_format(response[3:])
2127
if response[2] == '':
2128
repo_bzrdir = a_bzrdir
2130
repo_bzrdir = RemoteBzrDir(
2131
a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
2133
remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2134
remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2135
format=format, setup_stacking=False, name=name)
2136
# XXX: We know this is a new branch, so it must have revno 0, revid
2137
# NULL_REVISION. Creating the branch locked would make this be unable
2138
# to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2139
remote_branch._last_revision_info_cache = 0, NULL_REVISION
2140
return remote_branch
2142
def make_tags(self, branch):
2144
return self._custom_format.make_tags(branch)
1218
return 'Remote BZR Branch'
1220
def get_format_string(self):
1221
return 'Remote BZR Branch'
1223
def open(self, a_bzrdir):
1224
return a_bzrdir.open_branch()
1226
def initialize(self, a_bzrdir):
1227
return a_bzrdir.create_branch()
2146
1229
def supports_tags(self):
2147
1230
# Remote branches might support tags, but we won't know until we
2148
1231
# access the real remote branch.
2150
return self._custom_format.supports_tags()
2152
def supports_stacking(self):
2154
return self._custom_format.supports_stacking()
2156
def supports_set_append_revisions_only(self):
2158
return self._custom_format.supports_set_append_revisions_only()
2161
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
1235
class RemoteBranch(branch.Branch):
2162
1236
"""Branch stored on a server accessed by HPSS RPC.
2164
1238
At the moment most operations are mapped down to simple file operations.
2167
1241
def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2168
_client=None, format=None, setup_stacking=True, name=None):
2169
1243
"""Create a RemoteBranch instance.
2171
1245
:param real_branch: An optional local implementation of the branch
2172
1246
format, usually accessing the data via the VFS.
2173
1247
:param _client: Private parameter for testing.
2174
:param format: A RemoteBranchFormat object, None to create one
2175
automatically. If supplied it should have a network_name already
2177
:param setup_stacking: If True make an RPC call to determine the
2178
stacked (or not) status of the branch. If False assume the branch
2180
:param name: Colocated branch name
2182
1249
# We intentionally don't call the parent class's __init__, because it
2183
1250
# will try to assign to self.tags, which is a property in this subclass.
2184
1251
# And the parent's __init__ doesn't do much anyway.
1252
self._revision_id_to_revno_cache = None
1253
self._revision_history_cache = None
1254
self._last_revision_info_cache = None
2185
1255
self.bzrdir = remote_bzrdir
2186
1256
if _client is not None:
2187
1257
self._client = _client
2339
1366
:raises UnstackableRepositoryFormat: If the repository does not support
2343
# there may not be a repository yet, so we can't use
2344
# self._translate_error, so we can't use self._call either.
2345
response = self._client.call('Branch.get_stacked_on_url',
2346
self._remote_path())
2347
except errors.ErrorFromSmartServer, err:
2348
# there may not be a repository yet, so we can't call through
2349
# its _translate_error
2350
_translate_error(err, branch=self)
2351
except errors.UnknownSmartMethod, err:
2353
return self._real_branch.get_stacked_on_url()
2354
if response[0] != 'ok':
2355
raise errors.UnexpectedSmartServerResponse(response)
2358
def set_stacked_on_url(self, url):
2359
branch.Branch.set_stacked_on_url(self, url)
2361
self._is_stacked = False
2363
self._is_stacked = True
2365
def _vfs_get_tags_bytes(self):
2367
return self._real_branch._get_tags_bytes()
2369
def _get_tags_bytes(self):
2370
medium = self._client._medium
2371
if medium._is_remote_before((1, 13)):
2372
return self._vfs_get_tags_bytes()
2374
response = self._call('Branch.get_tags_bytes', self._remote_path())
2375
except errors.UnknownSmartMethod:
2376
medium._remember_remote_is_before((1, 13))
2377
return self._vfs_get_tags_bytes()
2380
def _vfs_set_tags_bytes(self, bytes):
2382
return self._real_branch._set_tags_bytes(bytes)
2384
def _set_tags_bytes(self, bytes):
2385
medium = self._client._medium
2386
if medium._is_remote_before((1, 18)):
2387
self._vfs_set_tags_bytes(bytes)
2391
self._remote_path(), self._lock_token, self._repo_lock_token)
2392
response = self._call_with_body_bytes(
2393
'Branch.set_tags_bytes', args, bytes)
2394
except errors.UnknownSmartMethod:
2395
medium._remember_remote_is_before((1, 18))
2396
self._vfs_set_tags_bytes(bytes)
1370
return self._real_branch.get_stacked_on_url()
2398
1372
def lock_read(self):
2399
"""Lock the branch for read operations.
2401
:return: A bzrlib.lock.LogicalLockResult.
2403
1373
self.repository.lock_read()
2404
1374
if not self._lock_mode:
2405
self._note_lock('r')
2406
1375
self._lock_mode = 'r'
2407
1376
self._lock_count = 1
2408
1377
if self._real_branch is not None:
2409
1378
self._real_branch.lock_read()
2411
1380
self._lock_count += 1
2412
return lock.LogicalLockResult(self.unlock)
2414
1382
def _remote_lock_write(self, token):
2415
1383
if token is None:
2416
1384
branch_token = repo_token = ''
2418
1386
branch_token = token
2419
repo_token = self.repository.lock_write().repository_token
1387
repo_token = self.repository.lock_write()
2420
1388
self.repository.unlock()
2421
err_context = {'token': token}
2422
response = self._call(
2423
'Branch.lock_write', self._remote_path(), branch_token,
2424
repo_token or '', **err_context)
1389
path = self.bzrdir._path_for_remote_call(self._client)
1391
response = self._client.call(
1392
'Branch.lock_write', path, branch_token, repo_token or '')
1393
except errors.ErrorFromSmartServer, err:
1394
self._translate_error(err, token=token)
2425
1395
if response[0] != 'ok':
2426
1396
raise errors.UnexpectedSmartServerResponse(response)
2427
1397
ok, branch_token, repo_token = response
2428
1398
return branch_token, repo_token
2430
1400
def lock_write(self, token=None):
2431
1401
if not self._lock_mode:
2432
self._note_lock('w')
2433
1402
# Lock the branch and repo in one remote call.
2434
1403
remote_tokens = self._remote_lock_write(token)
2435
1404
self._lock_token, self._repo_lock_token = remote_tokens
2559
def _remote_path(self):
2560
return self.bzrdir._path_for_remote_call(self._client)
2562
1510
def _set_last_revision_descendant(self, revision_id, other_branch,
2563
1511
allow_diverged=False, allow_overwrite_descendant=False):
2564
# This performs additional work to meet the hook contract; while its
2565
# undesirable, we have to synthesise the revno to call the hook, and
2566
# not calling the hook is worse as it means changes can't be prevented.
2567
# Having calculated this though, we can't just call into
2568
# set_last_revision_info as a simple call, because there is a set_rh
2569
# hook that some folk may still be using.
2570
old_revno, old_revid = self.last_revision_info()
2571
history = self._lefthand_history(revision_id)
2572
self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2573
err_context = {'other_branch': other_branch}
2574
response = self._call('Branch.set_last_revision_ex',
2575
self._remote_path(), self._lock_token, self._repo_lock_token,
2576
revision_id, int(allow_diverged), int(allow_overwrite_descendant),
1512
path = self.bzrdir._path_for_remote_call(self._client)
1514
response = self._client.call('Branch.set_last_revision_ex',
1515
path, self._lock_token, self._repo_lock_token, revision_id,
1516
int(allow_diverged), int(allow_overwrite_descendant))
1517
except errors.ErrorFromSmartServer, err:
1518
self._translate_error(err, other_branch=other_branch)
2578
1519
self._clear_cached_state()
2579
1520
if len(response) != 3 and response[0] != 'ok':
2580
1521
raise errors.UnexpectedSmartServerResponse(response)
2581
1522
new_revno, new_revision_id = response[1:]
2582
1523
self._last_revision_info_cache = new_revno, new_revision_id
2583
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2584
1524
if self._real_branch is not None:
2585
1525
cache = new_revno, new_revision_id
2586
1526
self._real_branch._last_revision_info_cache = cache
2588
1528
def _set_last_revision(self, revision_id):
2589
old_revno, old_revid = self.last_revision_info()
2590
# This performs additional work to meet the hook contract; while its
2591
# undesirable, we have to synthesise the revno to call the hook, and
2592
# not calling the hook is worse as it means changes can't be prevented.
2593
# Having calculated this though, we can't just call into
2594
# set_last_revision_info as a simple call, because there is a set_rh
2595
# hook that some folk may still be using.
2596
history = self._lefthand_history(revision_id)
2597
self._run_pre_change_branch_tip_hooks(len(history), revision_id)
1529
path = self.bzrdir._path_for_remote_call(self._client)
2598
1530
self._clear_cached_state()
2599
response = self._call('Branch.set_last_revision',
2600
self._remote_path(), self._lock_token, self._repo_lock_token,
1532
response = self._client.call('Branch.set_last_revision',
1533
path, self._lock_token, self._repo_lock_token, revision_id)
1534
except errors.ErrorFromSmartServer, err:
1535
self._translate_error(err)
2602
1536
if response != ('ok',):
2603
1537
raise errors.UnexpectedSmartServerResponse(response)
2604
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2606
1539
@needs_write_lock
2607
1540
def set_revision_history(self, rev_history):
2614
1547
rev_id = rev_history[-1]
2615
1548
self._set_last_revision(rev_id)
2616
for hook in branch.Branch.hooks['set_rh']:
2617
hook(self, rev_history)
2618
1549
self._cache_revision_history(rev_history)
2620
def _get_parent_location(self):
2621
medium = self._client._medium
2622
if medium._is_remote_before((1, 13)):
2623
return self._vfs_get_parent_location()
2625
response = self._call('Branch.get_parent', self._remote_path())
2626
except errors.UnknownSmartMethod:
2627
medium._remember_remote_is_before((1, 13))
2628
return self._vfs_get_parent_location()
2629
if len(response) != 1:
2630
raise errors.UnexpectedSmartServerResponse(response)
2631
parent_location = response[0]
2632
if parent_location == '':
2634
return parent_location
2636
def _vfs_get_parent_location(self):
2638
return self._real_branch._get_parent_location()
2640
def _set_parent_location(self, url):
2641
medium = self._client._medium
2642
if medium._is_remote_before((1, 15)):
2643
return self._vfs_set_parent_location(url)
2645
call_url = url or ''
2646
if type(call_url) is not str:
2647
raise AssertionError('url must be a str or None (%s)' % url)
2648
response = self._call('Branch.set_parent_location',
2649
self._remote_path(), self._lock_token, self._repo_lock_token,
2651
except errors.UnknownSmartMethod:
2652
medium._remember_remote_is_before((1, 15))
2653
return self._vfs_set_parent_location(url)
2655
raise errors.UnexpectedSmartServerResponse(response)
2657
def _vfs_set_parent_location(self, url):
2659
return self._real_branch._set_parent_location(url)
1551
def get_parent(self):
1553
return self._real_branch.get_parent()
1555
def set_parent(self, url):
1557
return self._real_branch.set_parent(url)
1559
def set_stacked_on_url(self, stacked_location):
1560
"""Set the URL this branch is stacked against.
1562
:raises UnstackableBranchFormat: If the branch does not support
1564
:raises UnstackableRepositoryFormat: If the repository does not support
1568
return self._real_branch.set_stacked_on_url(stacked_location)
1570
def sprout(self, to_bzrdir, revision_id=None):
1571
# Like Branch.sprout, except that it sprouts a branch in the default
1572
# format, because RemoteBranches can't be created at arbitrary URLs.
1573
# XXX: if to_bzrdir is a RemoteBranch, this should perhaps do
1574
# to_bzrdir.create_branch...
1576
result = self._real_branch._format.initialize(to_bzrdir)
1577
self.copy_content_into(result, revision_id=revision_id)
1578
result.set_parent(self.bzrdir.root_transport.base)
2661
1581
@needs_write_lock
2662
1582
def pull(self, source, overwrite=False, stop_revision=None,
2722
1639
except errors.UnknownSmartMethod:
2723
1640
medium._remember_remote_is_before((1, 6))
2724
1641
self._clear_cached_state_of_remote_branch_only()
2725
self.set_revision_history(self._lefthand_history(revision_id,
2726
last_rev=last_rev,other_branch=other_branch))
1643
self._real_branch.generate_revision_history(
1644
revision_id, last_rev=last_rev, other_branch=other_branch)
1649
return self._real_branch.tags
2728
1651
def set_push_location(self, location):
2729
1652
self._ensure_real()
2730
1653
return self._real_branch.set_push_location(location)
2733
class RemoteConfig(object):
2734
"""A Config that reads and writes from smart verbs.
2736
It is a low-level object that considers config data to be name/value pairs
2737
that may be associated with a section. Assigning meaning to the these
2738
values is done at higher levels like bzrlib.config.TreeConfig.
2741
def get_option(self, name, section=None, default=None):
2742
"""Return the value associated with a named option.
2744
:param name: The name of the value
2745
:param section: The section the option is in (if any)
2746
:param default: The value to return if the value is not set
2747
:return: The value or default value
1656
def update_revisions(self, other, stop_revision=None, overwrite=False,
1658
"""See Branch.update_revisions."""
2750
configobj = self._get_configobj()
2752
section_obj = configobj
1661
if stop_revision is None:
1662
stop_revision = other.last_revision()
1663
if revision.is_null(stop_revision):
1664
# if there are no commits, we're done.
1666
self.fetch(other, stop_revision)
1669
# Just unconditionally set the new revision. We don't care if
1670
# the branches have diverged.
1671
self._set_last_revision(stop_revision)
2755
section_obj = configobj[section]
2758
return section_obj.get(name, default)
2759
except errors.UnknownSmartMethod:
2760
return self._vfs_get_option(name, section, default)
2762
def _response_to_configobj(self, response):
2763
if len(response[0]) and response[0][0] != 'ok':
2764
raise errors.UnexpectedSmartServerResponse(response)
2765
lines = response[1].read_body_bytes().splitlines()
2766
return config.ConfigObj(lines, encoding='utf-8')
2769
class RemoteBranchConfig(RemoteConfig):
2770
"""A RemoteConfig for Branches."""
2772
def __init__(self, branch):
2773
self._branch = branch
2775
def _get_configobj(self):
2776
path = self._branch._remote_path()
2777
response = self._branch._client.call_expecting_body(
2778
'Branch.get_config_file', path)
2779
return self._response_to_configobj(response)
2781
def set_option(self, value, name, section=None):
2782
"""Set the value associated with a named option.
2784
:param value: The value to set
2785
:param name: The name of the value to set
2786
:param section: The section the option is in (if any)
2788
medium = self._branch._client._medium
2789
if medium._is_remote_before((1, 14)):
2790
return self._vfs_set_option(value, name, section)
2792
path = self._branch._remote_path()
2793
response = self._branch._client.call('Branch.set_config_option',
2794
path, self._branch._lock_token, self._branch._repo_lock_token,
2795
value.encode('utf8'), name, section or '')
2796
except errors.UnknownSmartMethod:
2797
medium._remember_remote_is_before((1, 14))
2798
return self._vfs_set_option(value, name, section)
2800
raise errors.UnexpectedSmartServerResponse(response)
2802
def _real_object(self):
2803
self._branch._ensure_real()
2804
return self._branch._real_branch
2806
def _vfs_set_option(self, value, name, section=None):
2807
return self._real_object()._get_config().set_option(
2808
value, name, section)
2811
class RemoteBzrDirConfig(RemoteConfig):
2812
"""A RemoteConfig for BzrDirs."""
2814
def __init__(self, bzrdir):
2815
self._bzrdir = bzrdir
2817
def _get_configobj(self):
2818
medium = self._bzrdir._client._medium
2819
verb = 'BzrDir.get_config_file'
2820
if medium._is_remote_before((1, 15)):
2821
raise errors.UnknownSmartMethod(verb)
2822
path = self._bzrdir._path_for_remote_call(self._bzrdir._client)
2823
response = self._bzrdir._call_expecting_body(
2825
return self._response_to_configobj(response)
2827
def _vfs_get_option(self, name, section, default):
2828
return self._real_object()._get_config().get_option(
2829
name, section, default)
2831
def set_option(self, value, name, section=None):
2832
"""Set the value associated with a named option.
2834
:param value: The value to set
2835
:param name: The name of the value to set
2836
:param section: The section the option is in (if any)
2838
return self._real_object()._get_config().set_option(
2839
value, name, section)
2841
def _real_object(self):
2842
self._bzrdir._ensure_real()
2843
return self._bzrdir._real_bzrdir
1673
medium = self._client._medium
1674
if not medium._is_remote_before((1, 6)):
1676
self._set_last_revision_descendant(stop_revision, other)
1678
except errors.UnknownSmartMethod:
1679
medium._remember_remote_is_before((1, 6))
1680
# Fallback for pre-1.6 servers: check for divergence
1681
# client-side, then do _set_last_revision.
1682
last_rev = revision.ensure_null(self.last_revision())
1684
graph = self.repository.get_graph()
1685
if self._check_if_descendant_or_diverged(
1686
stop_revision, last_rev, graph, other):
1687
# stop_revision is a descendant of last_rev, but we aren't
1688
# overwriting, so we're done.
1690
self._set_last_revision(stop_revision)
2847
1695
def _extract_tar(tar, to_dir):
added
removed
bzrlib/remote.py
