13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
# TODO: At some point, handle upgrades by just passing the whole request
18
# across to run on the server.
19
22
from bzrlib import (
30
repository as _mod_repository,
32
revision as _mod_revision,
36
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
33
from bzrlib.branch import BranchReferenceFormat
37
34
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
38
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
35
from bzrlib.decorators import needs_read_lock, needs_write_lock
39
36
from bzrlib.errors import (
41
38
SmartProtocolError,
43
40
from bzrlib.lockable_files import LockableFiles
44
from bzrlib.smart import client, vfs, repository as smart_repo
41
from bzrlib.smart import client, vfs
45
42
from bzrlib.revision import ensure_null, NULL_REVISION
46
from bzrlib.repository import RepositoryWriteLockResult
47
43
from bzrlib.trace import mutter, note, warning
50
class _RpcHelper(object):
51
"""Mixin class that helps with issuing RPCs."""
53
def _call(self, method, *args, **err_context):
55
return self._client.call(method, *args)
56
except errors.ErrorFromSmartServer, err:
57
self._translate_error(err, **err_context)
59
def _call_expecting_body(self, method, *args, **err_context):
61
return self._client.call_expecting_body(method, *args)
62
except errors.ErrorFromSmartServer, err:
63
self._translate_error(err, **err_context)
65
def _call_with_body_bytes(self, method, args, body_bytes, **err_context):
67
return self._client.call_with_body_bytes(method, args, body_bytes)
68
except errors.ErrorFromSmartServer, err:
69
self._translate_error(err, **err_context)
71
def _call_with_body_bytes_expecting_body(self, method, args, body_bytes,
74
return self._client.call_with_body_bytes_expecting_body(
75
method, args, body_bytes)
76
except errors.ErrorFromSmartServer, err:
77
self._translate_error(err, **err_context)
80
def response_tuple_to_repo_format(response):
81
"""Convert a response tuple describing a repository format to a format."""
82
format = RemoteRepositoryFormat()
83
format._rich_root_data = (response[0] == 'yes')
84
format._supports_tree_reference = (response[1] == 'yes')
85
format._supports_external_lookups = (response[2] == 'yes')
86
format._network_name = response[3]
90
46
# Note: RemoteBzrDirFormat is in bzrdir.py
92
class RemoteBzrDir(BzrDir, _RpcHelper):
48
class RemoteBzrDir(BzrDir):
93
49
"""Control directory on a remote server, accessed via bzr:// or similar."""
95
def __init__(self, transport, format, _client=None, _force_probe=False):
51
def __init__(self, transport, _client=None):
96
52
"""Construct a RemoteBzrDir.
98
54
:param _client: Private parameter for testing. Disables probing and the
99
55
use of a real bzrdir.
101
BzrDir.__init__(self, transport, format)
57
BzrDir.__init__(self, transport, RemoteBzrDirFormat())
102
58
# this object holds a delegated bzrdir that uses file-level operations
103
59
# to talk to the other side
104
60
self._real_bzrdir = None
105
self._has_working_tree = None
106
# 1-shot cache for the call pattern 'create_branch; open_branch' - see
107
# create_branch for details.
108
self._next_open_branch_result = None
110
62
if _client is None:
111
63
medium = transport.get_smart_medium()
112
64
self._client = client._SmartClient(medium)
114
66
self._client = _client
121
return '%s(%r)' % (self.__class__.__name__, self._client)
123
def _probe_bzrdir(self):
124
medium = self._client._medium
125
69
path = self._path_for_remote_call(self._client)
126
if medium._is_remote_before((2, 1)):
130
self._rpc_open_2_1(path)
132
except errors.UnknownSmartMethod:
133
medium._remember_remote_is_before((2, 1))
136
def _rpc_open_2_1(self, path):
137
response = self._call('BzrDir.open_2.1', path)
138
if response == ('no',):
139
raise errors.NotBranchError(path=self.root_transport.base)
140
elif response[0] == 'yes':
141
if response[1] == 'yes':
142
self._has_working_tree = True
143
elif response[1] == 'no':
144
self._has_working_tree = False
146
raise errors.UnexpectedSmartServerResponse(response)
148
raise errors.UnexpectedSmartServerResponse(response)
150
def _rpc_open(self, path):
151
response = self._call('BzrDir.open', path)
70
response = self._client.call('BzrDir.open', path)
152
71
if response not in [('yes',), ('no',)]:
153
72
raise errors.UnexpectedSmartServerResponse(response)
154
73
if response == ('no',):
155
raise errors.NotBranchError(path=self.root_transport.base)
74
raise errors.NotBranchError(path=transport.base)
157
76
def _ensure_real(self):
158
77
"""Ensure that there is a _real_bzrdir set.
160
79
Used before calls to self._real_bzrdir.
162
81
if not self._real_bzrdir:
163
if 'hpssvfs' in debug.debug_flags:
165
warning('VFS BzrDir access triggered\n%s',
166
''.join(traceback.format_stack()))
167
82
self._real_bzrdir = BzrDir.open_from_transport(
168
83
self.root_transport, _server_formats=False)
169
self._format._network_name = \
170
self._real_bzrdir._format.network_name()
85
def cloning_metadir(self, stacked=False):
87
return self._real_bzrdir.cloning_metadir(stacked)
172
89
def _translate_error(self, err, **context):
173
90
_translate_error(err, bzrdir=self, **context)
175
def break_lock(self):
176
# Prevent aliasing problems in the next_open_branch_result cache.
177
# See create_branch for rationale.
178
self._next_open_branch_result = None
179
return BzrDir.break_lock(self)
181
def _vfs_cloning_metadir(self, require_stacking=False):
183
return self._real_bzrdir.cloning_metadir(
184
require_stacking=require_stacking)
186
def cloning_metadir(self, require_stacking=False):
187
medium = self._client._medium
188
if medium._is_remote_before((1, 13)):
189
return self._vfs_cloning_metadir(require_stacking=require_stacking)
190
verb = 'BzrDir.cloning_metadir'
195
path = self._path_for_remote_call(self._client)
197
response = self._call(verb, path, stacking)
198
except errors.UnknownSmartMethod:
199
medium._remember_remote_is_before((1, 13))
200
return self._vfs_cloning_metadir(require_stacking=require_stacking)
201
except errors.UnknownErrorFromSmartServer, err:
202
if err.error_tuple != ('BranchReference',):
204
# We need to resolve the branch reference to determine the
205
# cloning_metadir. This causes unnecessary RPCs to open the
206
# referenced branch (and bzrdir, etc) but only when the caller
207
# didn't already resolve the branch reference.
208
referenced_branch = self.open_branch()
209
return referenced_branch.bzrdir.cloning_metadir()
210
if len(response) != 3:
211
raise errors.UnexpectedSmartServerResponse(response)
212
control_name, repo_name, branch_info = response
213
if len(branch_info) != 2:
214
raise errors.UnexpectedSmartServerResponse(response)
215
branch_ref, branch_name = branch_info
216
format = bzrdir.network_format_registry.get(control_name)
218
format.repository_format = repository.network_format_registry.get(
220
if branch_ref == 'ref':
221
# XXX: we need possible_transports here to avoid reopening the
222
# connection to the referenced location
223
ref_bzrdir = BzrDir.open(branch_name)
224
branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
225
format.set_branch_format(branch_format)
226
elif branch_ref == 'branch':
228
format.set_branch_format(
229
branch.network_format_registry.get(branch_name))
231
raise errors.UnexpectedSmartServerResponse(response)
234
92
def create_repository(self, shared=False):
235
# as per meta1 formats - just delegate to the format object which may
237
result = self._format.repository_format.initialize(self, shared)
238
if not isinstance(result, RemoteRepository):
239
return self.open_repository()
94
self._real_bzrdir.create_repository(shared=shared)
95
return self.open_repository()
243
97
def destroy_repository(self):
244
98
"""See BzrDir.destroy_repository"""
245
99
self._ensure_real()
246
100
self._real_bzrdir.destroy_repository()
248
def create_branch(self, name=None):
249
# as per meta1 formats - just delegate to the format object which may
251
real_branch = self._format.get_branch_format().initialize(self,
253
if not isinstance(real_branch, RemoteBranch):
254
result = RemoteBranch(self, self.find_repository(), real_branch,
258
# BzrDir.clone_on_transport() uses the result of create_branch but does
259
# not return it to its callers; we save approximately 8% of our round
260
# trips by handing the branch we created back to the first caller to
261
# open_branch rather than probing anew. Long term we need a API in
262
# bzrdir that doesn't discard result objects (like result_branch).
264
self._next_open_branch_result = result
102
def create_branch(self):
104
real_branch = self._real_bzrdir.create_branch()
105
return RemoteBranch(self, self.find_repository(), real_branch)
267
def destroy_branch(self, name=None):
107
def destroy_branch(self):
268
108
"""See BzrDir.destroy_branch"""
269
109
self._ensure_real()
270
self._real_bzrdir.destroy_branch(name=name)
271
self._next_open_branch_result = None
110
self._real_bzrdir.destroy_branch()
273
112
def create_workingtree(self, revision_id=None, from_branch=None):
274
113
raise errors.NotLocalUrl(self.transport.base)
276
def find_branch_format(self, name=None):
115
def find_branch_format(self):
277
116
"""Find the branch 'format' for this bzrdir.
279
118
This might be a synthetic object for e.g. RemoteBranch and SVN.
281
b = self.open_branch(name=name)
120
b = self.open_branch()
284
def get_branch_reference(self, name=None):
123
def get_branch_reference(self):
285
124
"""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':
125
path = self._path_for_remote_call(self._client)
127
response = self._client.call('BzrDir.open_branch', path)
128
except errors.ErrorFromSmartServer, err:
129
self._translate_error(err)
130
if response[0] == 'ok':
131
if response[1] == '':
132
# branch at this location.
135
# a branch reference, use the existing BranchReference logic.
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
138
raise errors.UnexpectedSmartServerResponse(response)
325
def _get_tree_branch(self, name=None):
140
def _get_tree_branch(self):
326
141
"""See BzrDir._get_tree_branch()."""
327
return None, self.open_branch(name=name)
142
return None, self.open_branch()
329
def open_branch(self, name=None, unsupported=False,
330
ignore_fallbacks=False):
144
def open_branch(self, _unsupported=False):
332
146
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':
147
reference_url = self.get_branch_reference()
148
if reference_url is None:
149
# branch at this location.
150
return RemoteBranch(self, self.find_repository())
340
152
# a branch reference, use the existing BranchReference logic.
341
153
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):
154
return format.open(self, _found=True, location=reference_url)
156
def open_repository(self):
157
path = self._path_for_remote_call(self._client)
364
158
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)
161
response = self._client.call(verb, path)
395
162
except errors.UnknownSmartMethod:
398
raise errors.UnknownSmartMethod('BzrDir.find_repository{3,2,}')
163
verb = 'BzrDir.find_repository'
164
response = self._client.call(verb, path)
165
except errors.ErrorFromSmartServer, err:
166
self._translate_error(err)
399
167
if response[0] != 'ok':
400
168
raise errors.UnexpectedSmartServerResponse(response)
401
if len(response) != 6:
169
if verb == 'BzrDir.find_repository':
170
# servers that don't support the V2 method don't support external
172
response = response + ('no', )
173
if not (len(response) == 5):
402
174
raise SmartProtocolError('incorrect response length %s' % (response,))
403
175
if response[1] == '':
404
# repo is at this dir.
405
format = response_tuple_to_repo_format(response[2:])
176
format = RemoteRepositoryFormat()
177
format.rich_root_data = (response[2] == 'yes')
178
format.supports_tree_reference = (response[3] == 'yes')
179
# No wire format to check this yet.
180
format.supports_external_lookups = (response[4] == 'yes')
406
181
# Used to support creating a real format instance when needed.
407
182
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)
183
return RemoteRepository(self, format)
414
185
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
187
def open_workingtree(self, recommend_upgrade=True):
423
if self.has_workingtree():
189
if self._real_bzrdir.has_workingtree():
424
190
raise errors.NotLocalUrl(self.root_transport)
426
192
raise errors.NoWorkingTree(self.root_transport.base)
473
237
the attributes rich_root_data and supports_tree_reference are set
474
238
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
242
_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
244
def initialize(self, a_bzrdir, shared=False):
245
if not isinstance(a_bzrdir, RemoteBzrDir):
544
246
prior_repo = self._creating_bzrdir.open_repository()
545
247
prior_repo._ensure_real()
546
result = prior_repo._real_repository._format.initialize(
248
return prior_repo._real_repository._format.initialize(
547
249
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
250
return a_bzrdir.create_repository(shared=shared)
601
252
def open(self, a_bzrdir):
602
253
if not isinstance(a_bzrdir, RemoteBzrDir):
603
254
raise AssertionError('%r is not a RemoteBzrDir' % (a_bzrdir,))
604
255
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
257
def get_format_description(self):
628
return 'Remote: ' + self._custom_format.get_format_description()
258
return 'bzr remote repository'
630
260
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):
261
return self.__class__ == other.__class__
263
def check_conversion_target(self, target_format):
264
if self.rich_root_data and not target_format.rich_root_data:
265
raise errors.BadConversionTarget(
266
'Does not support rich root data.', target_format)
267
if (self.supports_tree_reference and
268
not getattr(target_format, 'supports_tree_reference', False)):
269
raise errors.BadConversionTarget(
270
'Does not support nested trees', target_format)
273
class RemoteRepository(object):
652
274
"""Repository accessed over rpc.
654
276
For the moment most operations are performed using local transport-backed
748
345
self._ensure_real()
749
346
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
348
def _ensure_real(self):
796
349
"""Ensure that there is a _real_repository set.
798
351
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
353
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
354
self.bzrdir._ensure_real()
815
355
self._set_real_repository(
816
356
self.bzrdir._real_bzrdir.open_repository())
865
413
for line in lines:
866
414
d = tuple(line.split())
867
415
revision_graph[d[0]] = d[1:]
869
417
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
419
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,))
420
"""See Repository.has_revision()."""
421
if revision_id == NULL_REVISION:
422
# The null revision is always present.
424
path = self.bzrdir._path_for_remote_call(self._client)
425
response = self._client.call(
426
'Repository.has_revision', path, revision_id)
427
if response[0] not in ('yes', 'no'):
428
raise errors.UnexpectedSmartServerResponse(response)
429
if response[0] == 'yes':
431
for fallback_repo in self._fallback_repositories:
432
if fallback_repo.has_revision(revision_id):
886
436
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)
437
"""See Repository.has_revisions()."""
438
# FIXME: This does many roundtrips, particularly when there are
439
# fallback repositories. -- mbp 20080905
441
for revision_id in revision_ids:
442
if self.has_revision(revision_id):
443
result.add(revision_id)
899
def _has_same_fallbacks(self, other_repo):
900
"""Returns true if the repositories have the same fallbacks."""
901
# XXX: copied from Repository; it should be unified into a base class
902
# <https://bugs.launchpad.net/bzr/+bug/401622>
903
my_fb = self._fallback_repositories
904
other_fb = other_repo._fallback_repositories
905
if len(my_fb) != len(other_fb):
907
for f, g in zip(my_fb, other_fb):
908
if not f.has_same_location(g):
912
446
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
447
return (self.__class__ == other.__class__ and
917
448
self.bzrdir.transport.base == other.bzrdir.transport.base)
919
450
def get_graph(self, other_repository=None):
920
451
"""Return the graph for this repository format"""
921
parents_provider = self._make_parents_provider(other_repository)
452
parents_provider = self
453
if (other_repository is not None and
454
other_repository.bzrdir.transport.base !=
455
self.bzrdir.transport.base):
456
parents_provider = graph._StackedParentsProvider(
457
[parents_provider, other_repository._make_parents_provider()])
922
458
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
460
def gather_stats(self, revid=None, committers=None):
934
461
"""See Repository.gather_stats()."""
935
462
path = self.bzrdir._path_for_remote_call(self._client)
1236
723
def add_fallback_repository(self, repository):
1237
724
"""Add a repository to use for looking up data not held locally.
1239
726
:param repository: A repository.
1241
if not self._format.supports_external_lookups:
1242
raise errors.UnstackableRepositoryFormat(
1243
self._format.network_name(), self.base)
728
# XXX: At the moment the RemoteRepository will allow fallbacks
729
# unconditionally - however, a _real_repository will usually exist,
730
# and may raise an error if it's not accommodated by the underlying
731
# format. Eventually we should check when opening the repository
732
# whether it's willing to allow them or not.
1244
734
# We need to accumulate additional repositories here, to pass them in
1245
735
# 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
736
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(
737
# They are also seen by the fallback repository. If it doesn't exist
738
# yet they'll be added then. This implicitly copies them.
1273
741
def add_inventory(self, revid, inv, parents):
1274
742
self._ensure_real()
1275
743
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
745
def add_revision(self, rev_id, rev, inv=None, config=None):
1285
746
self._ensure_real()
1286
747
return self._real_repository.add_revision(
1396
831
self._ensure_real()
1397
832
return self._real_repository._get_versioned_file_checker(
1398
833
revisions, revision_versions_cache)
1400
835
def iter_files_bytes(self, desired_files):
1401
836
"""See Repository.iter_file_bytes.
1403
838
self._ensure_real()
1404
839
return self._real_repository.iter_files_bytes(desired_files)
1406
def get_parent_map(self, revision_ids):
842
def _fetch_order(self):
843
"""Decorate the real repository for now.
845
In the long term getting this back from the remote repository as part
846
of open would be more efficient.
849
return self._real_repository._fetch_order
852
def _fetch_uses_deltas(self):
853
"""Decorate the real repository for now.
855
In the long term getting this back from the remote repository as part
856
of open would be more efficient.
859
return self._real_repository._fetch_uses_deltas
862
def _fetch_reconcile(self):
863
"""Decorate the real repository for now.
865
In the long term getting this back from the remote repository as part
866
of open would be more efficient.
869
return self._real_repository._fetch_reconcile
871
def get_parent_map(self, keys):
1407
872
"""See bzrlib.Graph.get_parent_map()."""
1408
return self._make_parents_provider().get_parent_map(revision_ids)
873
# Hack to build up the caching logic.
874
ancestry = self._parents_map
876
# Repository is not locked, so there's no cache.
877
missing_revisions = set(keys)
880
missing_revisions = set(key for key in keys if key not in ancestry)
881
if missing_revisions:
882
parent_map = self._get_parent_map(missing_revisions)
883
if 'hpss' in debug.debug_flags:
884
mutter('retransmitted revisions: %d of %d',
885
len(set(ancestry).intersection(parent_map)),
887
ancestry.update(parent_map)
888
present_keys = [k for k in keys if k in ancestry]
889
if 'hpss' in debug.debug_flags:
890
if self._requested_parents is not None and len(ancestry) != 0:
891
self._requested_parents.update(present_keys)
892
mutter('Current RemoteRepository graph hit rate: %d%%',
893
100.0 * len(self._requested_parents) / len(ancestry))
894
return dict((k, ancestry[k]) for k in present_keys)
1410
def _get_parent_map_rpc(self, keys):
896
def _get_parent_map(self, keys):
1411
897
"""Helper for get_parent_map that performs the RPC."""
1412
898
medium = self._client._medium
1413
899
if medium._is_remote_before((1, 2)):
1414
900
# We already found out that the server can't understand
1415
901
# 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
903
# XXX: Note that this will issue a deprecation warning. This is ok
904
# :- its because we're working with a deprecated server anyway, and
905
# the user will almost certainly have seen a warning about the
906
# server version already.
907
rg = self.get_revision_graph()
908
# There is an api discrepency between get_parent_map and
1424
909
# get_revision_graph. Specifically, a "key:()" pair in
1425
910
# get_revision_graph just means a node has no parents. For
1426
911
# "get_parent_map" it means the node is a ghost. So fix up the
1751
1202
:param recipe: A search recipe (start, stop, count).
1752
1203
:return: Serialised bytes.
1754
start_keys = ' '.join(recipe[1])
1755
stop_keys = ' '.join(recipe[2])
1756
count = str(recipe[3])
1205
start_keys = ' '.join(recipe[0])
1206
stop_keys = ' '.join(recipe[1])
1207
count = str(recipe[2])
1757
1208
return '\n'.join((start_keys, stop_keys, count))
1759
def _serialise_search_result(self, search_result):
1760
if isinstance(search_result, graph.PendingAncestryResult):
1761
parts = ['ancestry-of']
1762
parts.extend(search_result.heads)
1764
recipe = search_result.get_recipe()
1765
parts = [recipe[0], self._serialise_search_recipe(recipe)]
1766
return '\n'.join(parts)
1769
path = self.bzrdir._path_for_remote_call(self._client)
1771
response = self._call('PackRepository.autopack', path)
1772
except errors.UnknownSmartMethod:
1774
self._real_repository._pack_collection.autopack()
1777
if response[0] != 'ok':
1778
raise errors.UnexpectedSmartServerResponse(response)
1781
class RemoteStreamSink(repository.StreamSink):
1783
def _insert_real(self, stream, src_format, resume_tokens):
1784
self.target_repo._ensure_real()
1785
sink = self.target_repo._real_repository._get_sink()
1786
result = sink.insert_stream(stream, src_format, resume_tokens)
1788
self.target_repo.autopack()
1791
def insert_stream(self, stream, src_format, resume_tokens):
1792
target = self.target_repo
1793
target._unstacked_provider.missing_keys.clear()
1794
candidate_calls = [('Repository.insert_stream_1.19', (1, 19))]
1795
if target._lock_token:
1796
candidate_calls.append(('Repository.insert_stream_locked', (1, 14)))
1797
lock_args = (target._lock_token or '',)
1799
candidate_calls.append(('Repository.insert_stream', (1, 13)))
1801
client = target._client
1802
medium = client._medium
1803
path = target.bzrdir._path_for_remote_call(client)
1804
# Probe for the verb to use with an empty stream before sending the
1805
# real stream to it. We do this both to avoid the risk of sending a
1806
# large request that is then rejected, and because we don't want to
1807
# implement a way to buffer, rewind, or restart the stream.
1809
for verb, required_version in candidate_calls:
1810
if medium._is_remote_before(required_version):
1813
# We've already done the probing (and set _is_remote_before) on
1814
# a previous insert.
1817
byte_stream = smart_repo._stream_to_byte_stream([], src_format)
1819
response = client.call_with_body_stream(
1820
(verb, path, '') + lock_args, byte_stream)
1821
except errors.UnknownSmartMethod:
1822
medium._remember_remote_is_before(required_version)
1828
return self._insert_real(stream, src_format, resume_tokens)
1829
self._last_inv_record = None
1830
self._last_substream = None
1831
if required_version < (1, 19):
1832
# Remote side doesn't support inventory deltas. Wrap the stream to
1833
# make sure we don't send any. If the stream contains inventory
1834
# deltas we'll interrupt the smart insert_stream request and
1836
stream = self._stop_stream_if_inventory_delta(stream)
1837
byte_stream = smart_repo._stream_to_byte_stream(
1839
resume_tokens = ' '.join(resume_tokens)
1840
response = client.call_with_body_stream(
1841
(verb, path, resume_tokens) + lock_args, byte_stream)
1842
if response[0][0] not in ('ok', 'missing-basis'):
1843
raise errors.UnexpectedSmartServerResponse(response)
1844
if self._last_substream is not None:
1845
# The stream included an inventory-delta record, but the remote
1846
# side isn't new enough to support them. So we need to send the
1847
# rest of the stream via VFS.
1848
self.target_repo.refresh_data()
1849
return self._resume_stream_with_vfs(response, src_format)
1850
if response[0][0] == 'missing-basis':
1851
tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1852
resume_tokens = tokens
1853
return resume_tokens, set(missing_keys)
1855
self.target_repo.refresh_data()
1858
def _resume_stream_with_vfs(self, response, src_format):
1859
"""Resume sending a stream via VFS, first resending the record and
1860
substream that couldn't be sent via an insert_stream verb.
1862
if response[0][0] == 'missing-basis':
1863
tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1864
# Ignore missing_keys, we haven't finished inserting yet
1867
def resume_substream():
1868
# Yield the substream that was interrupted.
1869
for record in self._last_substream:
1871
self._last_substream = None
1872
def resume_stream():
1873
# Finish sending the interrupted substream
1874
yield ('inventory-deltas', resume_substream())
1875
# Then simply continue sending the rest of the stream.
1876
for substream_kind, substream in self._last_stream:
1877
yield substream_kind, substream
1878
return self._insert_real(resume_stream(), src_format, tokens)
1880
def _stop_stream_if_inventory_delta(self, stream):
1881
"""Normally this just lets the original stream pass-through unchanged.
1883
However if any 'inventory-deltas' substream occurs it will stop
1884
streaming, and store the interrupted substream and stream in
1885
self._last_substream and self._last_stream so that the stream can be
1886
resumed by _resume_stream_with_vfs.
1889
stream_iter = iter(stream)
1890
for substream_kind, substream in stream_iter:
1891
if substream_kind == 'inventory-deltas':
1892
self._last_substream = substream
1893
self._last_stream = stream_iter
1896
yield substream_kind, substream
1899
class RemoteStreamSource(repository.StreamSource):
1900
"""Stream data from a remote server."""
1902
def get_stream(self, search):
1903
if (self.from_repository._fallback_repositories and
1904
self.to_format._fetch_order == 'topological'):
1905
return self._real_stream(self.from_repository, search)
1908
repos = [self.from_repository]
1914
repos.extend(repo._fallback_repositories)
1915
sources.append(repo)
1916
return self.missing_parents_chain(search, sources)
1918
def get_stream_for_missing_keys(self, missing_keys):
1919
self.from_repository._ensure_real()
1920
real_repo = self.from_repository._real_repository
1921
real_source = real_repo._get_source(self.to_format)
1922
return real_source.get_stream_for_missing_keys(missing_keys)
1924
def _real_stream(self, repo, search):
1925
"""Get a stream for search from repo.
1927
This never called RemoteStreamSource.get_stream, and is a heler
1928
for RemoteStreamSource._get_stream to allow getting a stream
1929
reliably whether fallback back because of old servers or trying
1930
to stream from a non-RemoteRepository (which the stacked support
1933
source = repo._get_source(self.to_format)
1934
if isinstance(source, RemoteStreamSource):
1936
source = repo._real_repository._get_source(self.to_format)
1937
return source.get_stream(search)
1939
def _get_stream(self, repo, search):
1940
"""Core worker to get a stream from repo for search.
1942
This is used by both get_stream and the stacking support logic. It
1943
deliberately gets a stream for repo which does not need to be
1944
self.from_repository. In the event that repo is not Remote, or
1945
cannot do a smart stream, a fallback is made to the generic
1946
repository._get_stream() interface, via self._real_stream.
1948
In the event of stacking, streams from _get_stream will not
1949
contain all the data for search - this is normal (see get_stream).
1951
:param repo: A repository.
1952
:param search: A search.
1954
# Fallbacks may be non-smart
1955
if not isinstance(repo, RemoteRepository):
1956
return self._real_stream(repo, search)
1957
client = repo._client
1958
medium = client._medium
1959
path = repo.bzrdir._path_for_remote_call(client)
1960
search_bytes = repo._serialise_search_result(search)
1961
args = (path, self.to_format.network_name())
1963
('Repository.get_stream_1.19', (1, 19)),
1964
('Repository.get_stream', (1, 13))]
1966
for verb, version in candidate_verbs:
1967
if medium._is_remote_before(version):
1970
response = repo._call_with_body_bytes_expecting_body(
1971
verb, args, search_bytes)
1972
except errors.UnknownSmartMethod:
1973
medium._remember_remote_is_before(version)
1975
response_tuple, response_handler = response
1979
return self._real_stream(repo, search)
1980
if response_tuple[0] != 'ok':
1981
raise errors.UnexpectedSmartServerResponse(response_tuple)
1982
byte_stream = response_handler.read_streamed_body()
1983
src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
1984
self._record_counter)
1985
if src_format.network_name() != repo._format.network_name():
1986
raise AssertionError(
1987
"Mismatched RemoteRepository and stream src %r, %r" % (
1988
src_format.network_name(), repo._format.network_name()))
1991
def missing_parents_chain(self, search, sources):
1992
"""Chain multiple streams together to handle stacking.
1994
:param search: The overall search to satisfy with streams.
1995
:param sources: A list of Repository objects to query.
1997
self.from_serialiser = self.from_repository._format._serializer
1998
self.seen_revs = set()
1999
self.referenced_revs = set()
2000
# If there are heads in the search, or the key count is > 0, we are not
2002
while not search.is_empty() and len(sources) > 1:
2003
source = sources.pop(0)
2004
stream = self._get_stream(source, search)
2005
for kind, substream in stream:
2006
if kind != 'revisions':
2007
yield kind, substream
2009
yield kind, self.missing_parents_rev_handler(substream)
2010
search = search.refine(self.seen_revs, self.referenced_revs)
2011
self.seen_revs = set()
2012
self.referenced_revs = set()
2013
if not search.is_empty():
2014
for kind, stream in self._get_stream(sources[0], search):
2017
def missing_parents_rev_handler(self, substream):
2018
for content in substream:
2019
revision_bytes = content.get_bytes_as('fulltext')
2020
revision = self.from_serialiser.read_revision_from_string(
2022
self.seen_revs.add(content.key[-1])
2023
self.referenced_revs.update(revision.parent_ids)
2027
1211
class RemoteBranchLockableFiles(LockableFiles):
2028
1212
"""A 'LockableFiles' implementation that talks to a smart server.
2030
1214
This is not a public interface class.
2047
1231
class RemoteBranchFormat(branch.BranchFormat):
2049
def __init__(self, network_name=None):
2050
super(RemoteBranchFormat, self).__init__()
2051
self._matchingbzrdir = RemoteBzrDirFormat()
2052
self._matchingbzrdir.set_branch_format(self)
2053
self._custom_format = None
2054
self._network_name = network_name
2056
1233
def __eq__(self, other):
2057
return (isinstance(other, RemoteBranchFormat) and
1234
return (isinstance(other, RemoteBranchFormat) and
2058
1235
self.__dict__ == other.__dict__)
2060
def _ensure_real(self):
2061
if self._custom_format is None:
2062
self._custom_format = branch.network_format_registry.get(
2065
1237
def get_format_description(self):
2067
return 'Remote: ' + self._custom_format.get_format_description()
2069
def network_name(self):
2070
return self._network_name
2072
def open(self, a_bzrdir, name=None, ignore_fallbacks=False):
2073
return a_bzrdir.open_branch(name=name,
2074
ignore_fallbacks=ignore_fallbacks)
2076
def _vfs_initialize(self, a_bzrdir, name):
2077
# Initialisation when using a local bzrdir object, or a non-vfs init
2078
# method is not available on the server.
2079
# self._custom_format is always set - the start of initialize ensures
2081
if isinstance(a_bzrdir, RemoteBzrDir):
2082
a_bzrdir._ensure_real()
2083
result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2086
# We assume the bzrdir is parameterised; it may not be.
2087
result = self._custom_format.initialize(a_bzrdir, name)
2088
if (isinstance(a_bzrdir, RemoteBzrDir) and
2089
not isinstance(result, RemoteBranch)):
2090
result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2094
def initialize(self, a_bzrdir, name=None):
2095
# 1) get the network name to use.
2096
if self._custom_format:
2097
network_name = self._custom_format.network_name()
2099
# Select the current bzrlib default and ask for that.
2100
reference_bzrdir_format = bzrdir.format_registry.get('default')()
2101
reference_format = reference_bzrdir_format.get_branch_format()
2102
self._custom_format = reference_format
2103
network_name = reference_format.network_name()
2104
# Being asked to create on a non RemoteBzrDir:
2105
if not isinstance(a_bzrdir, RemoteBzrDir):
2106
return self._vfs_initialize(a_bzrdir, name=name)
2107
medium = a_bzrdir._client._medium
2108
if medium._is_remote_before((1, 13)):
2109
return self._vfs_initialize(a_bzrdir, name=name)
2110
# Creating on a remote bzr dir.
2111
# 2) try direct creation via RPC
2112
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2113
if name is not None:
2114
# XXX JRV20100304: Support creating colocated branches
2115
raise errors.NoColocatedBranchSupport(self)
2116
verb = 'BzrDir.create_branch'
2118
response = a_bzrdir._call(verb, path, network_name)
2119
except errors.UnknownSmartMethod:
2120
# Fallback - use vfs methods
2121
medium._remember_remote_is_before((1, 13))
2122
return self._vfs_initialize(a_bzrdir, name=name)
2123
if response[0] != 'ok':
2124
raise errors.UnexpectedSmartServerResponse(response)
2125
# Turn the response into a RemoteRepository object.
2126
format = RemoteBranchFormat(network_name=response[1])
2127
repo_format = response_tuple_to_repo_format(response[3:])
2128
if response[2] == '':
2129
repo_bzrdir = a_bzrdir
2131
repo_bzrdir = RemoteBzrDir(
2132
a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
2134
remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2135
remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2136
format=format, setup_stacking=False, name=name)
2137
# XXX: We know this is a new branch, so it must have revno 0, revid
2138
# NULL_REVISION. Creating the branch locked would make this be unable
2139
# to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2140
remote_branch._last_revision_info_cache = 0, NULL_REVISION
2141
return remote_branch
2143
def make_tags(self, branch):
2145
return self._custom_format.make_tags(branch)
1238
return 'Remote BZR Branch'
1240
def get_format_string(self):
1241
return 'Remote BZR Branch'
1243
def open(self, a_bzrdir):
1244
return a_bzrdir.open_branch()
1246
def initialize(self, a_bzrdir):
1247
return a_bzrdir.create_branch()
2147
1249
def supports_tags(self):
2148
1250
# Remote branches might support tags, but we won't know until we
2149
1251
# access the real remote branch.
2151
return self._custom_format.supports_tags()
2153
def supports_stacking(self):
2155
return self._custom_format.supports_stacking()
2157
def supports_set_append_revisions_only(self):
2159
return self._custom_format.supports_set_append_revisions_only()
2162
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
1255
class RemoteBranch(branch.Branch):
2163
1256
"""Branch stored on a server accessed by HPSS RPC.
2165
1258
At the moment most operations are mapped down to simple file operations.
2168
1261
def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2169
_client=None, format=None, setup_stacking=True, name=None):
2170
1263
"""Create a RemoteBranch instance.
2172
1265
:param real_branch: An optional local implementation of the branch
2173
1266
format, usually accessing the data via the VFS.
2174
1267
:param _client: Private parameter for testing.
2175
:param format: A RemoteBranchFormat object, None to create one
2176
automatically. If supplied it should have a network_name already
2178
:param setup_stacking: If True make an RPC call to determine the
2179
stacked (or not) status of the branch. If False assume the branch
2181
:param name: Colocated branch name
2183
1269
# We intentionally don't call the parent class's __init__, because it
2184
1270
# will try to assign to self.tags, which is a property in this subclass.
2185
1271
# And the parent's __init__ doesn't do much anyway.
1272
self._revision_id_to_revno_cache = None
1273
self._revision_history_cache = None
1274
self._last_revision_info_cache = None
2186
1275
self.bzrdir = remote_bzrdir
2187
1276
if _client is not None:
2188
1277
self._client = _client
2352
1421
except errors.UnknownSmartMethod, err:
2353
1422
self._ensure_real()
2354
1423
return self._real_branch.get_stacked_on_url()
2355
if response[0] != 'ok':
2356
raise errors.UnexpectedSmartServerResponse(response)
2359
def set_stacked_on_url(self, url):
2360
branch.Branch.set_stacked_on_url(self, url)
2362
self._is_stacked = False
2364
self._is_stacked = True
2366
def _vfs_get_tags_bytes(self):
2368
return self._real_branch._get_tags_bytes()
2370
def _get_tags_bytes(self):
2371
medium = self._client._medium
2372
if medium._is_remote_before((1, 13)):
2373
return self._vfs_get_tags_bytes()
2375
response = self._call('Branch.get_tags_bytes', self._remote_path())
2376
except errors.UnknownSmartMethod:
2377
medium._remember_remote_is_before((1, 13))
2378
return self._vfs_get_tags_bytes()
2381
def _vfs_set_tags_bytes(self, bytes):
2383
return self._real_branch._set_tags_bytes(bytes)
2385
def _set_tags_bytes(self, bytes):
2386
medium = self._client._medium
2387
if medium._is_remote_before((1, 18)):
2388
self._vfs_set_tags_bytes(bytes)
2392
self._remote_path(), self._lock_token, self._repo_lock_token)
2393
response = self._call_with_body_bytes(
2394
'Branch.set_tags_bytes', args, bytes)
2395
except errors.UnknownSmartMethod:
2396
medium._remember_remote_is_before((1, 18))
2397
self._vfs_set_tags_bytes(bytes)
2399
1425
def lock_read(self):
2400
"""Lock the branch for read operations.
2402
:return: A bzrlib.lock.LogicalLockResult.
2404
1426
self.repository.lock_read()
2405
1427
if not self._lock_mode:
2406
self._note_lock('r')
2407
1428
self._lock_mode = 'r'
2408
1429
self._lock_count = 1
2409
1430
if self._real_branch is not None:
2410
1431
self._real_branch.lock_read()
2412
1433
self._lock_count += 1
2413
return lock.LogicalLockResult(self.unlock)
2415
1435
def _remote_lock_write(self, token):
2416
1436
if token is None:
2417
1437
branch_token = repo_token = ''
2419
1439
branch_token = token
2420
repo_token = self.repository.lock_write().repository_token
1440
repo_token = self.repository.lock_write()
2421
1441
self.repository.unlock()
2422
err_context = {'token': token}
2423
response = self._call(
2424
'Branch.lock_write', self._remote_path(), branch_token,
2425
repo_token or '', **err_context)
1443
response = self._client.call(
1444
'Branch.lock_write', self._remote_path(),
1445
branch_token, repo_token or '')
1446
except errors.ErrorFromSmartServer, err:
1447
self._translate_error(err, token=token)
2426
1448
if response[0] != 'ok':
2427
1449
raise errors.UnexpectedSmartServerResponse(response)
2428
1450
ok, branch_token, repo_token = response
2429
1451
return branch_token, repo_token
2431
1453
def lock_write(self, token=None):
2432
1454
if not self._lock_mode:
2433
self._note_lock('w')
2434
1455
# Lock the branch and repo in one remote call.
2435
1456
remote_tokens = self._remote_lock_write(token)
2436
1457
self._lock_token, self._repo_lock_token = remote_tokens
2563
1563
def _set_last_revision_descendant(self, revision_id, other_branch,
2564
1564
allow_diverged=False, allow_overwrite_descendant=False):
2565
# This performs additional work to meet the hook contract; while its
2566
# undesirable, we have to synthesise the revno to call the hook, and
2567
# not calling the hook is worse as it means changes can't be prevented.
2568
# Having calculated this though, we can't just call into
2569
# set_last_revision_info as a simple call, because there is a set_rh
2570
# hook that some folk may still be using.
2571
old_revno, old_revid = self.last_revision_info()
2572
history = self._lefthand_history(revision_id)
2573
self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2574
err_context = {'other_branch': other_branch}
2575
response = self._call('Branch.set_last_revision_ex',
2576
self._remote_path(), self._lock_token, self._repo_lock_token,
2577
revision_id, int(allow_diverged), int(allow_overwrite_descendant),
1566
response = self._client.call('Branch.set_last_revision_ex',
1567
self._remote_path(), self._lock_token, self._repo_lock_token, revision_id,
1568
int(allow_diverged), int(allow_overwrite_descendant))
1569
except errors.ErrorFromSmartServer, err:
1570
self._translate_error(err, other_branch=other_branch)
2579
1571
self._clear_cached_state()
2580
1572
if len(response) != 3 and response[0] != 'ok':
2581
1573
raise errors.UnexpectedSmartServerResponse(response)
2582
1574
new_revno, new_revision_id = response[1:]
2583
1575
self._last_revision_info_cache = new_revno, new_revision_id
2584
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2585
1576
if self._real_branch is not None:
2586
1577
cache = new_revno, new_revision_id
2587
1578
self._real_branch._last_revision_info_cache = cache
2589
1580
def _set_last_revision(self, revision_id):
2590
old_revno, old_revid = self.last_revision_info()
2591
# This performs additional work to meet the hook contract; while its
2592
# undesirable, we have to synthesise the revno to call the hook, and
2593
# not calling the hook is worse as it means changes can't be prevented.
2594
# Having calculated this though, we can't just call into
2595
# set_last_revision_info as a simple call, because there is a set_rh
2596
# hook that some folk may still be using.
2597
history = self._lefthand_history(revision_id)
2598
self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2599
1581
self._clear_cached_state()
2600
response = self._call('Branch.set_last_revision',
2601
self._remote_path(), self._lock_token, self._repo_lock_token,
1583
response = self._client.call('Branch.set_last_revision',
1584
self._remote_path(), self._lock_token, self._repo_lock_token, revision_id)
1585
except errors.ErrorFromSmartServer, err:
1586
self._translate_error(err)
2603
1587
if response != ('ok',):
2604
1588
raise errors.UnexpectedSmartServerResponse(response)
2605
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2607
1590
@needs_write_lock
2608
1591
def set_revision_history(self, rev_history):
2615
1598
rev_id = rev_history[-1]
2616
1599
self._set_last_revision(rev_id)
2617
for hook in branch.Branch.hooks['set_rh']:
2618
hook(self, rev_history)
2619
1600
self._cache_revision_history(rev_history)
2621
def _get_parent_location(self):
2622
medium = self._client._medium
2623
if medium._is_remote_before((1, 13)):
2624
return self._vfs_get_parent_location()
2626
response = self._call('Branch.get_parent', self._remote_path())
2627
except errors.UnknownSmartMethod:
2628
medium._remember_remote_is_before((1, 13))
2629
return self._vfs_get_parent_location()
2630
if len(response) != 1:
2631
raise errors.UnexpectedSmartServerResponse(response)
2632
parent_location = response[0]
2633
if parent_location == '':
2635
return parent_location
2637
def _vfs_get_parent_location(self):
2639
return self._real_branch._get_parent_location()
2641
def _set_parent_location(self, url):
2642
medium = self._client._medium
2643
if medium._is_remote_before((1, 15)):
2644
return self._vfs_set_parent_location(url)
2646
call_url = url or ''
2647
if type(call_url) is not str:
2648
raise AssertionError('url must be a str or None (%s)' % url)
2649
response = self._call('Branch.set_parent_location',
2650
self._remote_path(), self._lock_token, self._repo_lock_token,
2652
except errors.UnknownSmartMethod:
2653
medium._remember_remote_is_before((1, 15))
2654
return self._vfs_set_parent_location(url)
2656
raise errors.UnexpectedSmartServerResponse(response)
2658
def _vfs_set_parent_location(self, url):
2660
return self._real_branch._set_parent_location(url)
1602
def get_parent(self):
1604
return self._real_branch.get_parent()
1606
def set_parent(self, url):
1608
return self._real_branch.set_parent(url)
1610
def set_stacked_on_url(self, stacked_location):
1611
"""Set the URL this branch is stacked against.
1613
:raises UnstackableBranchFormat: If the branch does not support
1615
:raises UnstackableRepositoryFormat: If the repository does not support
1619
return self._real_branch.set_stacked_on_url(stacked_location)
1621
def sprout(self, to_bzrdir, revision_id=None):
1622
# Like Branch.sprout, except that it sprouts a branch in the default
1623
# format, because RemoteBranches can't be created at arbitrary URLs.
1624
# XXX: if to_bzrdir is a RemoteBranch, this should perhaps do
1625
# to_bzrdir.create_branch...
1627
result = self._real_branch._format.initialize(to_bzrdir)
1628
self.copy_content_into(result, revision_id=revision_id)
1629
result.set_parent(self.bzrdir.root_transport.base)
2662
1632
@needs_write_lock
2663
1633
def pull(self, source, overwrite=False, stop_revision=None,
2723
1689
except errors.UnknownSmartMethod:
2724
1690
medium._remember_remote_is_before((1, 6))
2725
1691
self._clear_cached_state_of_remote_branch_only()
2726
self.set_revision_history(self._lefthand_history(revision_id,
2727
last_rev=last_rev,other_branch=other_branch))
1693
self._real_branch.generate_revision_history(
1694
revision_id, last_rev=last_rev, other_branch=other_branch)
1699
return self._real_branch.tags
2729
1701
def set_push_location(self, location):
2730
1702
self._ensure_real()
2731
1703
return self._real_branch.set_push_location(location)
2734
class RemoteConfig(object):
2735
"""A Config that reads and writes from smart verbs.
2737
It is a low-level object that considers config data to be name/value pairs
2738
that may be associated with a section. Assigning meaning to the these
2739
values is done at higher levels like bzrlib.config.TreeConfig.
2742
def get_option(self, name, section=None, default=None):
2743
"""Return the value associated with a named option.
2745
:param name: The name of the value
2746
:param section: The section the option is in (if any)
2747
:param default: The value to return if the value is not set
2748
:return: The value or default value
1706
def update_revisions(self, other, stop_revision=None, overwrite=False,
1708
"""See Branch.update_revisions."""
2751
configobj = self._get_configobj()
2753
section_obj = configobj
1711
if stop_revision is None:
1712
stop_revision = other.last_revision()
1713
if revision.is_null(stop_revision):
1714
# if there are no commits, we're done.
1716
self.fetch(other, stop_revision)
1719
# Just unconditionally set the new revision. We don't care if
1720
# the branches have diverged.
1721
self._set_last_revision(stop_revision)
2756
section_obj = configobj[section]
2759
return section_obj.get(name, default)
2760
except errors.UnknownSmartMethod:
2761
return self._vfs_get_option(name, section, default)
2763
def _response_to_configobj(self, response):
2764
if len(response[0]) and response[0][0] != 'ok':
2765
raise errors.UnexpectedSmartServerResponse(response)
2766
lines = response[1].read_body_bytes().splitlines()
2767
return config.ConfigObj(lines, encoding='utf-8')
2770
class RemoteBranchConfig(RemoteConfig):
2771
"""A RemoteConfig for Branches."""
2773
def __init__(self, branch):
2774
self._branch = branch
2776
def _get_configobj(self):
2777
path = self._branch._remote_path()
2778
response = self._branch._client.call_expecting_body(
2779
'Branch.get_config_file', path)
2780
return self._response_to_configobj(response)
2782
def set_option(self, value, name, section=None):
2783
"""Set the value associated with a named option.
2785
:param value: The value to set
2786
:param name: The name of the value to set
2787
:param section: The section the option is in (if any)
2789
medium = self._branch._client._medium
2790
if medium._is_remote_before((1, 14)):
2791
return self._vfs_set_option(value, name, section)
2792
if isinstance(value, dict):
2793
if medium._is_remote_before((2, 2)):
2794
return self._vfs_set_option(value, name, section)
2795
return self._set_config_option_dict(value, name, section)
2797
return self._set_config_option(value, name, section)
2799
def _set_config_option(self, value, name, section):
2801
path = self._branch._remote_path()
2802
response = self._branch._client.call('Branch.set_config_option',
2803
path, self._branch._lock_token, self._branch._repo_lock_token,
2804
value.encode('utf8'), name, section or '')
2805
except errors.UnknownSmartMethod:
2806
medium = self._branch._client._medium
2807
medium._remember_remote_is_before((1, 14))
2808
return self._vfs_set_option(value, name, section)
2810
raise errors.UnexpectedSmartServerResponse(response)
2812
def _serialize_option_dict(self, option_dict):
2814
for key, value in option_dict.items():
2815
if isinstance(key, unicode):
2816
key = key.encode('utf8')
2817
if isinstance(value, unicode):
2818
value = value.encode('utf8')
2819
utf8_dict[key] = value
2820
return bencode.bencode(utf8_dict)
2822
def _set_config_option_dict(self, value, name, section):
2824
path = self._branch._remote_path()
2825
serialised_dict = self._serialize_option_dict(value)
2826
response = self._branch._client.call(
2827
'Branch.set_config_option_dict',
2828
path, self._branch._lock_token, self._branch._repo_lock_token,
2829
serialised_dict, name, section or '')
2830
except errors.UnknownSmartMethod:
2831
medium = self._branch._client._medium
2832
medium._remember_remote_is_before((2, 2))
2833
return self._vfs_set_option(value, name, section)
2835
raise errors.UnexpectedSmartServerResponse(response)
2837
def _real_object(self):
2838
self._branch._ensure_real()
2839
return self._branch._real_branch
2841
def _vfs_set_option(self, value, name, section=None):
2842
return self._real_object()._get_config().set_option(
2843
value, name, section)
2846
class RemoteBzrDirConfig(RemoteConfig):
2847
"""A RemoteConfig for BzrDirs."""
2849
def __init__(self, bzrdir):
2850
self._bzrdir = bzrdir
2852
def _get_configobj(self):
2853
medium = self._bzrdir._client._medium
2854
verb = 'BzrDir.get_config_file'
2855
if medium._is_remote_before((1, 15)):
2856
raise errors.UnknownSmartMethod(verb)
2857
path = self._bzrdir._path_for_remote_call(self._bzrdir._client)
2858
response = self._bzrdir._call_expecting_body(
2860
return self._response_to_configobj(response)
2862
def _vfs_get_option(self, name, section, default):
2863
return self._real_object()._get_config().get_option(
2864
name, section, default)
2866
def set_option(self, value, name, section=None):
2867
"""Set the value associated with a named option.
2869
:param value: The value to set
2870
:param name: The name of the value to set
2871
:param section: The section the option is in (if any)
2873
return self._real_object()._get_config().set_option(
2874
value, name, section)
2876
def _real_object(self):
2877
self._bzrdir._ensure_real()
2878
return self._bzrdir._real_bzrdir
1723
medium = self._client._medium
1724
if not medium._is_remote_before((1, 6)):
1726
self._set_last_revision_descendant(stop_revision, other)
1728
except errors.UnknownSmartMethod:
1729
medium._remember_remote_is_before((1, 6))
1730
# Fallback for pre-1.6 servers: check for divergence
1731
# client-side, then do _set_last_revision.
1732
last_rev = revision.ensure_null(self.last_revision())
1734
graph = self.repository.get_graph()
1735
if self._check_if_descendant_or_diverged(
1736
stop_revision, last_rev, graph, other):
1737
# stop_revision is a descendant of last_rev, but we aren't
1738
# overwriting, so we're done.
1740
self._set_last_revision(stop_revision)
2882
1745
def _extract_tar(tar, to_dir):
added
removed
bzrlib/remote.py
