1
# Copyright (C) 2006, 2007, 2008, 2009 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
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
31
revision as _mod_revision,
34
from bzrlib.branch import BranchReferenceFormat
35
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
36
from bzrlib.decorators import needs_read_lock, needs_write_lock
37
from bzrlib.errors import (
41
from bzrlib.lockable_files import LockableFiles
42
from bzrlib.smart import client, vfs, repository as smart_repo
43
from bzrlib.revision import ensure_null, NULL_REVISION
44
from bzrlib.trace import mutter, note, warning
47
class _RpcHelper(object):
48
"""Mixin class that helps with issuing RPCs."""
50
def _call(self, method, *args, **err_context):
52
return self._client.call(method, *args)
53
except errors.ErrorFromSmartServer, err:
54
self._translate_error(err, **err_context)
56
def _call_expecting_body(self, method, *args, **err_context):
58
return self._client.call_expecting_body(method, *args)
59
except errors.ErrorFromSmartServer, err:
60
self._translate_error(err, **err_context)
62
def _call_with_body_bytes(self, method, args, body_bytes, **err_context):
64
return self._client.call_with_body_bytes(method, args, body_bytes)
65
except errors.ErrorFromSmartServer, err:
66
self._translate_error(err, **err_context)
68
def _call_with_body_bytes_expecting_body(self, method, args, body_bytes,
71
return self._client.call_with_body_bytes_expecting_body(
72
method, args, body_bytes)
73
except errors.ErrorFromSmartServer, err:
74
self._translate_error(err, **err_context)
77
def response_tuple_to_repo_format(response):
78
"""Convert a response tuple describing a repository format to a format."""
79
format = RemoteRepositoryFormat()
80
format._rich_root_data = (response[0] == 'yes')
81
format._supports_tree_reference = (response[1] == 'yes')
82
format._supports_external_lookups = (response[2] == 'yes')
83
format._network_name = response[3]
87
# Note: RemoteBzrDirFormat is in bzrdir.py
89
class RemoteBzrDir(BzrDir, _RpcHelper):
90
"""Control directory on a remote server, accessed via bzr:// or similar."""
92
def __init__(self, transport, format, _client=None):
93
"""Construct a RemoteBzrDir.
95
:param _client: Private parameter for testing. Disables probing and the
98
BzrDir.__init__(self, transport, format)
99
# this object holds a delegated bzrdir that uses file-level operations
100
# to talk to the other side
101
self._real_bzrdir = None
102
# 1-shot cache for the call pattern 'create_branch; open_branch' - see
103
# create_branch for details.
104
self._next_open_branch_result = None
107
medium = transport.get_smart_medium()
108
self._client = client._SmartClient(medium)
110
self._client = _client
113
path = self._path_for_remote_call(self._client)
114
response = self._call('BzrDir.open', path)
115
if response not in [('yes',), ('no',)]:
116
raise errors.UnexpectedSmartServerResponse(response)
117
if response == ('no',):
118
raise errors.NotBranchError(path=transport.base)
120
def _ensure_real(self):
121
"""Ensure that there is a _real_bzrdir set.
123
Used before calls to self._real_bzrdir.
125
if not self._real_bzrdir:
126
self._real_bzrdir = BzrDir.open_from_transport(
127
self.root_transport, _server_formats=False)
128
self._format._network_name = \
129
self._real_bzrdir._format.network_name()
131
def _translate_error(self, err, **context):
132
_translate_error(err, bzrdir=self, **context)
134
def break_lock(self):
135
# Prevent aliasing problems in the next_open_branch_result cache.
136
# See create_branch for rationale.
137
self._next_open_branch_result = None
138
return BzrDir.break_lock(self)
140
def _vfs_cloning_metadir(self, require_stacking=False):
142
return self._real_bzrdir.cloning_metadir(
143
require_stacking=require_stacking)
145
def cloning_metadir(self, require_stacking=False):
146
medium = self._client._medium
147
if medium._is_remote_before((1, 13)):
148
return self._vfs_cloning_metadir(require_stacking=require_stacking)
149
verb = 'BzrDir.cloning_metadir'
154
path = self._path_for_remote_call(self._client)
156
response = self._call(verb, path, stacking)
157
except errors.UnknownSmartMethod:
158
medium._remember_remote_is_before((1, 13))
159
return self._vfs_cloning_metadir(require_stacking=require_stacking)
160
except errors.UnknownErrorFromSmartServer, err:
161
if err.error_tuple != ('BranchReference',):
163
# We need to resolve the branch reference to determine the
164
# cloning_metadir. This causes unnecessary RPCs to open the
165
# referenced branch (and bzrdir, etc) but only when the caller
166
# didn't already resolve the branch reference.
167
referenced_branch = self.open_branch()
168
return referenced_branch.bzrdir.cloning_metadir()
169
if len(response) != 3:
170
raise errors.UnexpectedSmartServerResponse(response)
171
control_name, repo_name, branch_info = response
172
if len(branch_info) != 2:
173
raise errors.UnexpectedSmartServerResponse(response)
174
branch_ref, branch_name = branch_info
175
format = bzrdir.network_format_registry.get(control_name)
177
format.repository_format = repository.network_format_registry.get(
179
if branch_ref == 'ref':
180
# XXX: we need possible_transports here to avoid reopening the
181
# connection to the referenced location
182
ref_bzrdir = BzrDir.open(branch_name)
183
branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
184
format.set_branch_format(branch_format)
185
elif branch_ref == 'branch':
187
format.set_branch_format(
188
branch.network_format_registry.get(branch_name))
190
raise errors.UnexpectedSmartServerResponse(response)
193
def create_repository(self, shared=False):
194
# as per meta1 formats - just delegate to the format object which may
196
result = self._format.repository_format.initialize(self, shared)
197
if not isinstance(result, RemoteRepository):
198
return self.open_repository()
202
def destroy_repository(self):
203
"""See BzrDir.destroy_repository"""
205
self._real_bzrdir.destroy_repository()
207
def create_branch(self):
208
# as per meta1 formats - just delegate to the format object which may
210
real_branch = self._format.get_branch_format().initialize(self)
211
if not isinstance(real_branch, RemoteBranch):
212
result = RemoteBranch(self, self.find_repository(), real_branch)
215
# BzrDir.clone_on_transport() uses the result of create_branch but does
216
# not return it to its callers; we save approximately 8% of our round
217
# trips by handing the branch we created back to the first caller to
218
# open_branch rather than probing anew. Long term we need a API in
219
# bzrdir that doesn't discard result objects (like result_branch).
221
self._next_open_branch_result = result
224
def destroy_branch(self):
225
"""See BzrDir.destroy_branch"""
227
self._real_bzrdir.destroy_branch()
228
self._next_open_branch_result = None
230
def create_workingtree(self, revision_id=None, from_branch=None):
231
raise errors.NotLocalUrl(self.transport.base)
233
def find_branch_format(self):
234
"""Find the branch 'format' for this bzrdir.
236
This might be a synthetic object for e.g. RemoteBranch and SVN.
238
b = self.open_branch()
241
def get_branch_reference(self):
242
"""See BzrDir.get_branch_reference()."""
243
response = self._get_branch_reference()
244
if response[0] == 'ref':
249
def _get_branch_reference(self):
250
path = self._path_for_remote_call(self._client)
251
medium = self._client._medium
252
if not medium._is_remote_before((1, 13)):
254
response = self._call('BzrDir.open_branchV2', path)
255
if response[0] not in ('ref', 'branch'):
256
raise errors.UnexpectedSmartServerResponse(response)
258
except errors.UnknownSmartMethod:
259
medium._remember_remote_is_before((1, 13))
260
response = self._call('BzrDir.open_branch', path)
261
if response[0] != 'ok':
262
raise errors.UnexpectedSmartServerResponse(response)
263
if response[1] != '':
264
return ('ref', response[1])
266
return ('branch', '')
268
def _get_tree_branch(self):
269
"""See BzrDir._get_tree_branch()."""
270
return None, self.open_branch()
272
def open_branch(self, _unsupported=False, ignore_fallbacks=False):
274
raise NotImplementedError('unsupported flag support not implemented yet.')
275
if self._next_open_branch_result is not None:
276
# See create_branch for details.
277
result = self._next_open_branch_result
278
self._next_open_branch_result = None
280
response = self._get_branch_reference()
281
if response[0] == 'ref':
282
# a branch reference, use the existing BranchReference logic.
283
format = BranchReferenceFormat()
284
return format.open(self, _found=True, location=response[1],
285
ignore_fallbacks=ignore_fallbacks)
286
branch_format_name = response[1]
287
if not branch_format_name:
288
branch_format_name = None
289
format = RemoteBranchFormat(network_name=branch_format_name)
290
return RemoteBranch(self, self.find_repository(), format=format,
291
setup_stacking=not ignore_fallbacks)
293
def _open_repo_v1(self, path):
294
verb = 'BzrDir.find_repository'
295
response = self._call(verb, path)
296
if response[0] != 'ok':
297
raise errors.UnexpectedSmartServerResponse(response)
298
# servers that only support the v1 method don't support external
301
repo = self._real_bzrdir.open_repository()
302
response = response + ('no', repo._format.network_name())
303
return response, repo
305
def _open_repo_v2(self, path):
306
verb = 'BzrDir.find_repositoryV2'
307
response = self._call(verb, path)
308
if response[0] != 'ok':
309
raise errors.UnexpectedSmartServerResponse(response)
311
repo = self._real_bzrdir.open_repository()
312
response = response + (repo._format.network_name(),)
313
return response, repo
315
def _open_repo_v3(self, path):
316
verb = 'BzrDir.find_repositoryV3'
317
medium = self._client._medium
318
if medium._is_remote_before((1, 13)):
319
raise errors.UnknownSmartMethod(verb)
321
response = self._call(verb, path)
322
except errors.UnknownSmartMethod:
323
medium._remember_remote_is_before((1, 13))
325
if response[0] != 'ok':
326
raise errors.UnexpectedSmartServerResponse(response)
327
return response, None
329
def open_repository(self):
330
path = self._path_for_remote_call(self._client)
332
for probe in [self._open_repo_v3, self._open_repo_v2,
335
response, real_repo = probe(path)
337
except errors.UnknownSmartMethod:
340
raise errors.UnknownSmartMethod('BzrDir.find_repository{3,2,}')
341
if response[0] != 'ok':
342
raise errors.UnexpectedSmartServerResponse(response)
343
if len(response) != 6:
344
raise SmartProtocolError('incorrect response length %s' % (response,))
345
if response[1] == '':
346
# repo is at this dir.
347
format = response_tuple_to_repo_format(response[2:])
348
# Used to support creating a real format instance when needed.
349
format._creating_bzrdir = self
350
remote_repo = RemoteRepository(self, format)
351
format._creating_repo = remote_repo
352
if real_repo is not None:
353
remote_repo._set_real_repository(real_repo)
356
raise errors.NoRepositoryPresent(self)
358
def open_workingtree(self, recommend_upgrade=True):
360
if self._real_bzrdir.has_workingtree():
361
raise errors.NotLocalUrl(self.root_transport)
363
raise errors.NoWorkingTree(self.root_transport.base)
365
def _path_for_remote_call(self, client):
366
"""Return the path to be used for this bzrdir in a remote call."""
367
return client.remote_path_from_transport(self.root_transport)
369
def get_branch_transport(self, branch_format):
371
return self._real_bzrdir.get_branch_transport(branch_format)
373
def get_repository_transport(self, repository_format):
375
return self._real_bzrdir.get_repository_transport(repository_format)
377
def get_workingtree_transport(self, workingtree_format):
379
return self._real_bzrdir.get_workingtree_transport(workingtree_format)
381
def can_convert_format(self):
382
"""Upgrading of remote bzrdirs is not supported yet."""
385
def needs_format_conversion(self, format=None):
386
"""Upgrading of remote bzrdirs is not supported yet."""
388
symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
389
% 'needs_format_conversion(format=None)')
392
def clone(self, url, revision_id=None, force_new_repo=False,
393
preserve_stacking=False):
395
return self._real_bzrdir.clone(url, revision_id=revision_id,
396
force_new_repo=force_new_repo, preserve_stacking=preserve_stacking)
398
def _get_config(self):
399
return RemoteBzrDirConfig(self)
402
class RemoteRepositoryFormat(repository.RepositoryFormat):
403
"""Format for repositories accessed over a _SmartClient.
405
Instances of this repository are represented by RemoteRepository
408
The RemoteRepositoryFormat is parameterized during construction
409
to reflect the capabilities of the real, remote format. Specifically
410
the attributes rich_root_data and supports_tree_reference are set
411
on a per instance basis, and are not set (and should not be) at
414
:ivar _custom_format: If set, a specific concrete repository format that
415
will be used when initializing a repository with this
416
RemoteRepositoryFormat.
417
:ivar _creating_repo: If set, the repository object that this
418
RemoteRepositoryFormat was created for: it can be called into
419
to obtain data like the network name.
422
_matchingbzrdir = RemoteBzrDirFormat()
425
repository.RepositoryFormat.__init__(self)
426
self._custom_format = None
427
self._network_name = None
428
self._creating_bzrdir = None
429
self._supports_chks = None
430
self._supports_external_lookups = None
431
self._supports_tree_reference = None
432
self._rich_root_data = None
435
return "%s(_network_name=%r)" % (self.__class__.__name__,
439
def fast_deltas(self):
441
return self._custom_format.fast_deltas
444
def rich_root_data(self):
445
if self._rich_root_data is None:
447
self._rich_root_data = self._custom_format.rich_root_data
448
return self._rich_root_data
451
def supports_chks(self):
452
if self._supports_chks is None:
454
self._supports_chks = self._custom_format.supports_chks
455
return self._supports_chks
458
def supports_external_lookups(self):
459
if self._supports_external_lookups is None:
461
self._supports_external_lookups = \
462
self._custom_format.supports_external_lookups
463
return self._supports_external_lookups
466
def supports_tree_reference(self):
467
if self._supports_tree_reference is None:
469
self._supports_tree_reference = \
470
self._custom_format.supports_tree_reference
471
return self._supports_tree_reference
473
def _vfs_initialize(self, a_bzrdir, shared):
474
"""Helper for common code in initialize."""
475
if self._custom_format:
476
# Custom format requested
477
result = self._custom_format.initialize(a_bzrdir, shared=shared)
478
elif self._creating_bzrdir is not None:
479
# Use the format that the repository we were created to back
481
prior_repo = self._creating_bzrdir.open_repository()
482
prior_repo._ensure_real()
483
result = prior_repo._real_repository._format.initialize(
484
a_bzrdir, shared=shared)
486
# assume that a_bzr is a RemoteBzrDir but the smart server didn't
487
# support remote initialization.
488
# We delegate to a real object at this point (as RemoteBzrDir
489
# delegate to the repository format which would lead to infinite
490
# recursion if we just called a_bzrdir.create_repository.
491
a_bzrdir._ensure_real()
492
result = a_bzrdir._real_bzrdir.create_repository(shared=shared)
493
if not isinstance(result, RemoteRepository):
494
return self.open(a_bzrdir)
498
def initialize(self, a_bzrdir, shared=False):
499
# Being asked to create on a non RemoteBzrDir:
500
if not isinstance(a_bzrdir, RemoteBzrDir):
501
return self._vfs_initialize(a_bzrdir, shared)
502
medium = a_bzrdir._client._medium
503
if medium._is_remote_before((1, 13)):
504
return self._vfs_initialize(a_bzrdir, shared)
505
# Creating on a remote bzr dir.
506
# 1) get the network name to use.
507
if self._custom_format:
508
network_name = self._custom_format.network_name()
509
elif self._network_name:
510
network_name = self._network_name
512
# Select the current bzrlib default and ask for that.
513
reference_bzrdir_format = bzrdir.format_registry.get('default')()
514
reference_format = reference_bzrdir_format.repository_format
515
network_name = reference_format.network_name()
516
# 2) try direct creation via RPC
517
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
518
verb = 'BzrDir.create_repository'
524
response = a_bzrdir._call(verb, path, network_name, shared_str)
525
except errors.UnknownSmartMethod:
526
# Fallback - use vfs methods
527
medium._remember_remote_is_before((1, 13))
528
return self._vfs_initialize(a_bzrdir, shared)
530
# Turn the response into a RemoteRepository object.
531
format = response_tuple_to_repo_format(response[1:])
532
# Used to support creating a real format instance when needed.
533
format._creating_bzrdir = a_bzrdir
534
remote_repo = RemoteRepository(a_bzrdir, format)
535
format._creating_repo = remote_repo
538
def open(self, a_bzrdir):
539
if not isinstance(a_bzrdir, RemoteBzrDir):
540
raise AssertionError('%r is not a RemoteBzrDir' % (a_bzrdir,))
541
return a_bzrdir.open_repository()
543
def _ensure_real(self):
544
if self._custom_format is None:
545
self._custom_format = repository.network_format_registry.get(
549
def _fetch_order(self):
551
return self._custom_format._fetch_order
554
def _fetch_uses_deltas(self):
556
return self._custom_format._fetch_uses_deltas
559
def _fetch_reconcile(self):
561
return self._custom_format._fetch_reconcile
563
def get_format_description(self):
564
return 'bzr remote repository'
566
def __eq__(self, other):
567
return self.__class__ is other.__class__
569
def check_conversion_target(self, target_format):
570
if self.rich_root_data and not target_format.rich_root_data:
571
raise errors.BadConversionTarget(
572
'Does not support rich root data.', target_format,
574
if (self.supports_tree_reference and
575
not getattr(target_format, 'supports_tree_reference', False)):
576
raise errors.BadConversionTarget(
577
'Does not support nested trees', target_format,
580
def network_name(self):
581
if self._network_name:
582
return self._network_name
583
self._creating_repo._ensure_real()
584
return self._creating_repo._real_repository._format.network_name()
587
def pack_compresses(self):
589
return self._custom_format.pack_compresses
592
def _serializer(self):
594
return self._custom_format._serializer
597
class RemoteRepository(_RpcHelper):
598
"""Repository accessed over rpc.
600
For the moment most operations are performed using local transport-backed
604
def __init__(self, remote_bzrdir, format, real_repository=None, _client=None):
605
"""Create a RemoteRepository instance.
607
:param remote_bzrdir: The bzrdir hosting this repository.
608
:param format: The RemoteFormat object to use.
609
:param real_repository: If not None, a local implementation of the
610
repository logic for the repository, usually accessing the data
612
:param _client: Private testing parameter - override the smart client
613
to be used by the repository.
616
self._real_repository = real_repository
618
self._real_repository = None
619
self.bzrdir = remote_bzrdir
621
self._client = remote_bzrdir._client
623
self._client = _client
624
self._format = format
625
self._lock_mode = None
626
self._lock_token = None
628
self._leave_lock = False
629
# Cache of revision parents; misses are cached during read locks, and
630
# write locks when no _real_repository has been set.
631
self._unstacked_provider = graph.CachingParentsProvider(
632
get_parent_map=self._get_parent_map_rpc)
633
self._unstacked_provider.disable_cache()
635
# These depend on the actual remote format, so force them off for
636
# maximum compatibility. XXX: In future these should depend on the
637
# remote repository instance, but this is irrelevant until we perform
638
# reconcile via an RPC call.
639
self._reconcile_does_inventory_gc = False
640
self._reconcile_fixes_text_parents = False
641
self._reconcile_backsup_inventory = False
642
self.base = self.bzrdir.transport.base
643
# Additional places to query for data.
644
self._fallback_repositories = []
647
return "%s(%s)" % (self.__class__.__name__, self.base)
651
def abort_write_group(self, suppress_errors=False):
652
"""Complete a write group on the decorated repository.
654
Smart methods perform operations in a single step so this API
655
is not really applicable except as a compatibility thunk
656
for older plugins that don't use e.g. the CommitBuilder
659
:param suppress_errors: see Repository.abort_write_group.
662
return self._real_repository.abort_write_group(
663
suppress_errors=suppress_errors)
667
"""Decorate the real repository for now.
669
In the long term a full blown network facility is needed to avoid
670
creating a real repository object locally.
673
return self._real_repository.chk_bytes
675
def commit_write_group(self):
676
"""Complete a write group on the decorated repository.
678
Smart methods perform operations in a single step so this API
679
is not really applicable except as a compatibility thunk
680
for older plugins that don't use e.g. the CommitBuilder
684
return self._real_repository.commit_write_group()
686
def resume_write_group(self, tokens):
688
return self._real_repository.resume_write_group(tokens)
690
def suspend_write_group(self):
692
return self._real_repository.suspend_write_group()
694
def get_missing_parent_inventories(self, check_for_missing_texts=True):
696
return self._real_repository.get_missing_parent_inventories(
697
check_for_missing_texts=check_for_missing_texts)
699
def _get_rev_id_for_revno_vfs(self, revno, known_pair):
701
return self._real_repository.get_rev_id_for_revno(
704
def get_rev_id_for_revno(self, revno, known_pair):
705
"""See Repository.get_rev_id_for_revno."""
706
path = self.bzrdir._path_for_remote_call(self._client)
708
if self._client._medium._is_remote_before((1, 17)):
709
return self._get_rev_id_for_revno_vfs(revno, known_pair)
710
response = self._call(
711
'Repository.get_rev_id_for_revno', path, revno, known_pair)
712
except errors.UnknownSmartMethod:
713
self._client._medium._remember_remote_is_before((1, 17))
714
return self._get_rev_id_for_revno_vfs(revno, known_pair)
715
if response[0] == 'ok':
716
return True, response[1]
717
elif response[0] == 'history-incomplete':
718
known_pair = response[1:3]
719
for fallback in self._fallback_repositories:
720
found, result = fallback.get_rev_id_for_revno(revno, known_pair)
725
# Not found in any fallbacks
726
return False, known_pair
728
raise errors.UnexpectedSmartServerResponse(response)
730
def _ensure_real(self):
731
"""Ensure that there is a _real_repository set.
733
Used before calls to self._real_repository.
735
Note that _ensure_real causes many roundtrips to the server which are
736
not desirable, and prevents the use of smart one-roundtrip RPC's to
737
perform complex operations (such as accessing parent data, streaming
738
revisions etc). Adding calls to _ensure_real should only be done when
739
bringing up new functionality, adding fallbacks for smart methods that
740
require a fallback path, and never to replace an existing smart method
741
invocation. If in doubt chat to the bzr network team.
743
if self._real_repository is None:
744
if 'hpssvfs' in debug.debug_flags:
746
warning('VFS Repository access triggered\n%s',
747
''.join(traceback.format_stack()))
748
self._unstacked_provider.missing_keys.clear()
749
self.bzrdir._ensure_real()
750
self._set_real_repository(
751
self.bzrdir._real_bzrdir.open_repository())
753
def _translate_error(self, err, **context):
754
self.bzrdir._translate_error(err, repository=self, **context)
756
def find_text_key_references(self):
757
"""Find the text key references within the repository.
759
:return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
760
revision_ids. Each altered file-ids has the exact revision_ids that
761
altered it listed explicitly.
762
:return: A dictionary mapping text keys ((fileid, revision_id) tuples)
763
to whether they were referred to by the inventory of the
764
revision_id that they contain. The inventory texts from all present
765
revision ids are assessed to generate this report.
768
return self._real_repository.find_text_key_references()
770
def _generate_text_key_index(self):
771
"""Generate a new text key index for the repository.
773
This is an expensive function that will take considerable time to run.
775
:return: A dict mapping (file_id, revision_id) tuples to a list of
776
parents, also (file_id, revision_id) tuples.
779
return self._real_repository._generate_text_key_index()
781
def _get_revision_graph(self, revision_id):
782
"""Private method for using with old (< 1.2) servers to fallback."""
783
if revision_id is None:
785
elif revision.is_null(revision_id):
788
path = self.bzrdir._path_for_remote_call(self._client)
789
response = self._call_expecting_body(
790
'Repository.get_revision_graph', path, revision_id)
791
response_tuple, response_handler = response
792
if response_tuple[0] != 'ok':
793
raise errors.UnexpectedSmartServerResponse(response_tuple)
794
coded = response_handler.read_body_bytes()
796
# no revisions in this repository!
798
lines = coded.split('\n')
801
d = tuple(line.split())
802
revision_graph[d[0]] = d[1:]
804
return revision_graph
807
"""See Repository._get_sink()."""
808
return RemoteStreamSink(self)
810
def _get_source(self, to_format):
811
"""Return a source for streaming from this repository."""
812
return RemoteStreamSource(self, to_format)
815
def has_revision(self, revision_id):
816
"""True if this repository has a copy of the revision."""
817
# Copy of bzrlib.repository.Repository.has_revision
818
return revision_id in self.has_revisions((revision_id,))
821
def has_revisions(self, revision_ids):
822
"""Probe to find out the presence of multiple revisions.
824
:param revision_ids: An iterable of revision_ids.
825
:return: A set of the revision_ids that were present.
827
# Copy of bzrlib.repository.Repository.has_revisions
828
parent_map = self.get_parent_map(revision_ids)
829
result = set(parent_map)
830
if _mod_revision.NULL_REVISION in revision_ids:
831
result.add(_mod_revision.NULL_REVISION)
834
def _has_same_fallbacks(self, other_repo):
835
"""Returns true if the repositories have the same fallbacks."""
836
# XXX: copied from Repository; it should be unified into a base class
837
# <https://bugs.edge.launchpad.net/bzr/+bug/401622>
838
my_fb = self._fallback_repositories
839
other_fb = other_repo._fallback_repositories
840
if len(my_fb) != len(other_fb):
842
for f, g in zip(my_fb, other_fb):
843
if not f.has_same_location(g):
847
def has_same_location(self, other):
848
# TODO: Move to RepositoryBase and unify with the regular Repository
849
# one; unfortunately the tests rely on slightly different behaviour at
850
# present -- mbp 20090710
851
return (self.__class__ is other.__class__ and
852
self.bzrdir.transport.base == other.bzrdir.transport.base)
854
def get_graph(self, other_repository=None):
855
"""Return the graph for this repository format"""
856
parents_provider = self._make_parents_provider(other_repository)
857
return graph.Graph(parents_provider)
859
def gather_stats(self, revid=None, committers=None):
860
"""See Repository.gather_stats()."""
861
path = self.bzrdir._path_for_remote_call(self._client)
862
# revid can be None to indicate no revisions, not just NULL_REVISION
863
if revid is None or revision.is_null(revid):
867
if committers is None or not committers:
868
fmt_committers = 'no'
870
fmt_committers = 'yes'
871
response_tuple, response_handler = self._call_expecting_body(
872
'Repository.gather_stats', path, fmt_revid, fmt_committers)
873
if response_tuple[0] != 'ok':
874
raise errors.UnexpectedSmartServerResponse(response_tuple)
876
body = response_handler.read_body_bytes()
878
for line in body.split('\n'):
881
key, val_text = line.split(':')
882
if key in ('revisions', 'size', 'committers'):
883
result[key] = int(val_text)
884
elif key in ('firstrev', 'latestrev'):
885
values = val_text.split(' ')[1:]
886
result[key] = (float(values[0]), long(values[1]))
890
def find_branches(self, using=False):
891
"""See Repository.find_branches()."""
892
# should be an API call to the server.
894
return self._real_repository.find_branches(using=using)
896
def get_physical_lock_status(self):
897
"""See Repository.get_physical_lock_status()."""
898
# should be an API call to the server.
900
return self._real_repository.get_physical_lock_status()
902
def is_in_write_group(self):
903
"""Return True if there is an open write group.
905
write groups are only applicable locally for the smart server..
907
if self._real_repository:
908
return self._real_repository.is_in_write_group()
911
return self._lock_count >= 1
914
"""See Repository.is_shared()."""
915
path = self.bzrdir._path_for_remote_call(self._client)
916
response = self._call('Repository.is_shared', path)
917
if response[0] not in ('yes', 'no'):
918
raise SmartProtocolError('unexpected response code %s' % (response,))
919
return response[0] == 'yes'
921
def is_write_locked(self):
922
return self._lock_mode == 'w'
925
# wrong eventually - want a local lock cache context
926
if not self._lock_mode:
927
self._lock_mode = 'r'
929
self._unstacked_provider.enable_cache(cache_misses=True)
930
if self._real_repository is not None:
931
self._real_repository.lock_read()
932
for repo in self._fallback_repositories:
935
self._lock_count += 1
937
def _remote_lock_write(self, token):
938
path = self.bzrdir._path_for_remote_call(self._client)
941
err_context = {'token': token}
942
response = self._call('Repository.lock_write', path, token,
944
if response[0] == 'ok':
948
raise errors.UnexpectedSmartServerResponse(response)
950
def lock_write(self, token=None, _skip_rpc=False):
951
if not self._lock_mode:
953
if self._lock_token is not None:
954
if token != self._lock_token:
955
raise errors.TokenMismatch(token, self._lock_token)
956
self._lock_token = token
958
self._lock_token = self._remote_lock_write(token)
959
# if self._lock_token is None, then this is something like packs or
960
# svn where we don't get to lock the repo, or a weave style repository
961
# where we cannot lock it over the wire and attempts to do so will
963
if self._real_repository is not None:
964
self._real_repository.lock_write(token=self._lock_token)
965
if token is not None:
966
self._leave_lock = True
968
self._leave_lock = False
969
self._lock_mode = 'w'
971
cache_misses = self._real_repository is None
972
self._unstacked_provider.enable_cache(cache_misses=cache_misses)
973
for repo in self._fallback_repositories:
974
# Writes don't affect fallback repos
976
elif self._lock_mode == 'r':
977
raise errors.ReadOnlyError(self)
979
self._lock_count += 1
980
return self._lock_token or None
982
def leave_lock_in_place(self):
983
if not self._lock_token:
984
raise NotImplementedError(self.leave_lock_in_place)
985
self._leave_lock = True
987
def dont_leave_lock_in_place(self):
988
if not self._lock_token:
989
raise NotImplementedError(self.dont_leave_lock_in_place)
990
self._leave_lock = False
992
def _set_real_repository(self, repository):
993
"""Set the _real_repository for this repository.
995
:param repository: The repository to fallback to for non-hpss
996
implemented operations.
998
if self._real_repository is not None:
999
# Replacing an already set real repository.
1000
# We cannot do this [currently] if the repository is locked -
1001
# synchronised state might be lost.
1002
if self.is_locked():
1003
raise AssertionError('_real_repository is already set')
1004
if isinstance(repository, RemoteRepository):
1005
raise AssertionError()
1006
self._real_repository = repository
1007
# three code paths happen here:
1008
# 1) old servers, RemoteBranch.open() calls _ensure_real before setting
1009
# up stacking. In this case self._fallback_repositories is [], and the
1010
# real repo is already setup. Preserve the real repo and
1011
# RemoteRepository.add_fallback_repository will avoid adding
1013
# 2) new servers, RemoteBranch.open() sets up stacking, and when
1014
# ensure_real is triggered from a branch, the real repository to
1015
# set already has a matching list with separate instances, but
1016
# as they are also RemoteRepositories we don't worry about making the
1017
# lists be identical.
1018
# 3) new servers, RemoteRepository.ensure_real is triggered before
1019
# RemoteBranch.ensure real, in this case we get a repo with no fallbacks
1020
# and need to populate it.
1021
if (self._fallback_repositories and
1022
len(self._real_repository._fallback_repositories) !=
1023
len(self._fallback_repositories)):
1024
if len(self._real_repository._fallback_repositories):
1025
raise AssertionError(
1026
"cannot cleanly remove existing _fallback_repositories")
1027
for fb in self._fallback_repositories:
1028
self._real_repository.add_fallback_repository(fb)
1029
if self._lock_mode == 'w':
1030
# if we are already locked, the real repository must be able to
1031
# acquire the lock with our token.
1032
self._real_repository.lock_write(self._lock_token)
1033
elif self._lock_mode == 'r':
1034
self._real_repository.lock_read()
1036
def start_write_group(self):
1037
"""Start a write group on the decorated repository.
1039
Smart methods perform operations in a single step so this API
1040
is not really applicable except as a compatibility thunk
1041
for older plugins that don't use e.g. the CommitBuilder
1045
return self._real_repository.start_write_group()
1047
def _unlock(self, token):
1048
path = self.bzrdir._path_for_remote_call(self._client)
1050
# with no token the remote repository is not persistently locked.
1052
err_context = {'token': token}
1053
response = self._call('Repository.unlock', path, token,
1055
if response == ('ok',):
1058
raise errors.UnexpectedSmartServerResponse(response)
1061
if not self._lock_count:
1062
return lock.cant_unlock_not_held(self)
1063
self._lock_count -= 1
1064
if self._lock_count > 0:
1066
self._unstacked_provider.disable_cache()
1067
old_mode = self._lock_mode
1068
self._lock_mode = None
1070
# The real repository is responsible at present for raising an
1071
# exception if it's in an unfinished write group. However, it
1072
# normally will *not* actually remove the lock from disk - that's
1073
# done by the server on receiving the Repository.unlock call.
1074
# This is just to let the _real_repository stay up to date.
1075
if self._real_repository is not None:
1076
self._real_repository.unlock()
1078
# The rpc-level lock should be released even if there was a
1079
# problem releasing the vfs-based lock.
1081
# Only write-locked repositories need to make a remote method
1082
# call to perform the unlock.
1083
old_token = self._lock_token
1084
self._lock_token = None
1085
if not self._leave_lock:
1086
self._unlock(old_token)
1087
# Fallbacks are always 'lock_read()' so we don't pay attention to
1089
for repo in self._fallback_repositories:
1092
def break_lock(self):
1093
# should hand off to the network
1095
return self._real_repository.break_lock()
1097
def _get_tarball(self, compression):
1098
"""Return a TemporaryFile containing a repository tarball.
1100
Returns None if the server does not support sending tarballs.
1103
path = self.bzrdir._path_for_remote_call(self._client)
1105
response, protocol = self._call_expecting_body(
1106
'Repository.tarball', path, compression)
1107
except errors.UnknownSmartMethod:
1108
protocol.cancel_read_body()
1110
if response[0] == 'ok':
1111
# Extract the tarball and return it
1112
t = tempfile.NamedTemporaryFile()
1113
# TODO: rpc layer should read directly into it...
1114
t.write(protocol.read_body_bytes())
1117
raise errors.UnexpectedSmartServerResponse(response)
1119
def sprout(self, to_bzrdir, revision_id=None):
1120
# TODO: Option to control what format is created?
1122
dest_repo = self._real_repository._format.initialize(to_bzrdir,
1124
dest_repo.fetch(self, revision_id=revision_id)
1127
### These methods are just thin shims to the VFS object for now.
1129
def revision_tree(self, revision_id):
1131
return self._real_repository.revision_tree(revision_id)
1133
def get_serializer_format(self):
1135
return self._real_repository.get_serializer_format()
1137
def get_commit_builder(self, branch, parents, config, timestamp=None,
1138
timezone=None, committer=None, revprops=None,
1140
# FIXME: It ought to be possible to call this without immediately
1141
# triggering _ensure_real. For now it's the easiest thing to do.
1143
real_repo = self._real_repository
1144
builder = real_repo.get_commit_builder(branch, parents,
1145
config, timestamp=timestamp, timezone=timezone,
1146
committer=committer, revprops=revprops, revision_id=revision_id)
1149
def add_fallback_repository(self, repository):
1150
"""Add a repository to use for looking up data not held locally.
1152
:param repository: A repository.
1154
if not self._format.supports_external_lookups:
1155
raise errors.UnstackableRepositoryFormat(
1156
self._format.network_name(), self.base)
1157
# We need to accumulate additional repositories here, to pass them in
1160
if self.is_locked():
1161
# We will call fallback.unlock() when we transition to the unlocked
1162
# state, so always add a lock here. If a caller passes us a locked
1163
# repository, they are responsible for unlocking it later.
1164
repository.lock_read()
1165
self._fallback_repositories.append(repository)
1166
# If self._real_repository was parameterised already (e.g. because a
1167
# _real_branch had its get_stacked_on_url method called), then the
1168
# repository to be added may already be in the _real_repositories list.
1169
if self._real_repository is not None:
1170
fallback_locations = [repo.bzrdir.root_transport.base for repo in
1171
self._real_repository._fallback_repositories]
1172
if repository.bzrdir.root_transport.base not in fallback_locations:
1173
self._real_repository.add_fallback_repository(repository)
1175
def add_inventory(self, revid, inv, parents):
1177
return self._real_repository.add_inventory(revid, inv, parents)
1179
def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1182
return self._real_repository.add_inventory_by_delta(basis_revision_id,
1183
delta, new_revision_id, parents)
1185
def add_revision(self, rev_id, rev, inv=None, config=None):
1187
return self._real_repository.add_revision(
1188
rev_id, rev, inv=inv, config=config)
1191
def get_inventory(self, revision_id):
1193
return self._real_repository.get_inventory(revision_id)
1195
def iter_inventories(self, revision_ids, ordering=None):
1197
return self._real_repository.iter_inventories(revision_ids, ordering)
1200
def get_revision(self, revision_id):
1202
return self._real_repository.get_revision(revision_id)
1204
def get_transaction(self):
1206
return self._real_repository.get_transaction()
1209
def clone(self, a_bzrdir, revision_id=None):
1211
return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
1213
def make_working_trees(self):
1214
"""See Repository.make_working_trees"""
1216
return self._real_repository.make_working_trees()
1218
def refresh_data(self):
1219
"""Re-read any data needed to to synchronise with disk.
1221
This method is intended to be called after another repository instance
1222
(such as one used by a smart server) has inserted data into the
1223
repository. It may not be called during a write group, but may be
1224
called at any other time.
1226
if self.is_in_write_group():
1227
raise errors.InternalBzrError(
1228
"May not refresh_data while in a write group.")
1229
if self._real_repository is not None:
1230
self._real_repository.refresh_data()
1232
def revision_ids_to_search_result(self, result_set):
1233
"""Convert a set of revision ids to a graph SearchResult."""
1234
result_parents = set()
1235
for parents in self.get_graph().get_parent_map(
1236
result_set).itervalues():
1237
result_parents.update(parents)
1238
included_keys = result_set.intersection(result_parents)
1239
start_keys = result_set.difference(included_keys)
1240
exclude_keys = result_parents.difference(result_set)
1241
result = graph.SearchResult(start_keys, exclude_keys,
1242
len(result_set), result_set)
1246
def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1247
"""Return the revision ids that other has that this does not.
1249
These are returned in topological order.
1251
revision_id: only return revision ids included by revision_id.
1253
return repository.InterRepository.get(
1254
other, self).search_missing_revision_ids(revision_id, find_ghosts)
1256
def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
1258
# No base implementation to use as RemoteRepository is not a subclass
1259
# of Repository; so this is a copy of Repository.fetch().
1260
if fetch_spec is not None and revision_id is not None:
1261
raise AssertionError(
1262
"fetch_spec and revision_id are mutually exclusive.")
1263
if self.is_in_write_group():
1264
raise errors.InternalBzrError(
1265
"May not fetch while in a write group.")
1266
# fast path same-url fetch operations
1267
if (self.has_same_location(source)
1268
and fetch_spec is None
1269
and self._has_same_fallbacks(source)):
1270
# check that last_revision is in 'from' and then return a
1272
if (revision_id is not None and
1273
not revision.is_null(revision_id)):
1274
self.get_revision(revision_id)
1276
# if there is no specific appropriate InterRepository, this will get
1277
# the InterRepository base class, which raises an
1278
# IncompatibleRepositories when asked to fetch.
1279
inter = repository.InterRepository.get(source, self)
1280
return inter.fetch(revision_id=revision_id, pb=pb,
1281
find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1283
def create_bundle(self, target, base, fileobj, format=None):
1285
self._real_repository.create_bundle(target, base, fileobj, format)
1288
def get_ancestry(self, revision_id, topo_sorted=True):
1290
return self._real_repository.get_ancestry(revision_id, topo_sorted)
1292
def fileids_altered_by_revision_ids(self, revision_ids):
1294
return self._real_repository.fileids_altered_by_revision_ids(revision_ids)
1296
def _get_versioned_file_checker(self, revisions, revision_versions_cache):
1298
return self._real_repository._get_versioned_file_checker(
1299
revisions, revision_versions_cache)
1301
def iter_files_bytes(self, desired_files):
1302
"""See Repository.iter_file_bytes.
1305
return self._real_repository.iter_files_bytes(desired_files)
1307
def get_parent_map(self, revision_ids):
1308
"""See bzrlib.Graph.get_parent_map()."""
1309
return self._make_parents_provider().get_parent_map(revision_ids)
1311
def _get_parent_map_rpc(self, keys):
1312
"""Helper for get_parent_map that performs the RPC."""
1313
medium = self._client._medium
1314
if medium._is_remote_before((1, 2)):
1315
# We already found out that the server can't understand
1316
# Repository.get_parent_map requests, so just fetch the whole
1319
# Note that this reads the whole graph, when only some keys are
1320
# wanted. On this old server there's no way (?) to get them all
1321
# in one go, and the user probably will have seen a warning about
1322
# the server being old anyhow.
1323
rg = self._get_revision_graph(None)
1324
# There is an API discrepancy between get_parent_map and
1325
# get_revision_graph. Specifically, a "key:()" pair in
1326
# get_revision_graph just means a node has no parents. For
1327
# "get_parent_map" it means the node is a ghost. So fix up the
1328
# graph to correct this.
1329
# https://bugs.launchpad.net/bzr/+bug/214894
1330
# There is one other "bug" which is that ghosts in
1331
# get_revision_graph() are not returned at all. But we won't worry
1332
# about that for now.
1333
for node_id, parent_ids in rg.iteritems():
1334
if parent_ids == ():
1335
rg[node_id] = (NULL_REVISION,)
1336
rg[NULL_REVISION] = ()
1341
raise ValueError('get_parent_map(None) is not valid')
1342
if NULL_REVISION in keys:
1343
keys.discard(NULL_REVISION)
1344
found_parents = {NULL_REVISION:()}
1346
return found_parents
1349
# TODO(Needs analysis): We could assume that the keys being requested
1350
# from get_parent_map are in a breadth first search, so typically they
1351
# will all be depth N from some common parent, and we don't have to
1352
# have the server iterate from the root parent, but rather from the
1353
# keys we're searching; and just tell the server the keyspace we
1354
# already have; but this may be more traffic again.
1356
# Transform self._parents_map into a search request recipe.
1357
# TODO: Manage this incrementally to avoid covering the same path
1358
# repeatedly. (The server will have to on each request, but the less
1359
# work done the better).
1361
# Negative caching notes:
1362
# new server sends missing when a request including the revid
1363
# 'include-missing:' is present in the request.
1364
# missing keys are serialised as missing:X, and we then call
1365
# provider.note_missing(X) for-all X
1366
parents_map = self._unstacked_provider.get_cached_map()
1367
if parents_map is None:
1368
# Repository is not locked, so there's no cache.
1370
# start_set is all the keys in the cache
1371
start_set = set(parents_map)
1372
# result set is all the references to keys in the cache
1373
result_parents = set()
1374
for parents in parents_map.itervalues():
1375
result_parents.update(parents)
1376
stop_keys = result_parents.difference(start_set)
1377
# We don't need to send ghosts back to the server as a position to
1379
stop_keys.difference_update(self._unstacked_provider.missing_keys)
1380
key_count = len(parents_map)
1381
if (NULL_REVISION in result_parents
1382
and NULL_REVISION in self._unstacked_provider.missing_keys):
1383
# If we pruned NULL_REVISION from the stop_keys because it's also
1384
# in our cache of "missing" keys we need to increment our key count
1385
# by 1, because the reconsitituted SearchResult on the server will
1386
# still consider NULL_REVISION to be an included key.
1388
included_keys = start_set.intersection(result_parents)
1389
start_set.difference_update(included_keys)
1390
recipe = ('manual', start_set, stop_keys, key_count)
1391
body = self._serialise_search_recipe(recipe)
1392
path = self.bzrdir._path_for_remote_call(self._client)
1394
if type(key) is not str:
1396
"key %r not a plain string" % (key,))
1397
verb = 'Repository.get_parent_map'
1398
args = (path, 'include-missing:') + tuple(keys)
1400
response = self._call_with_body_bytes_expecting_body(
1402
except errors.UnknownSmartMethod:
1403
# Server does not support this method, so get the whole graph.
1404
# Worse, we have to force a disconnection, because the server now
1405
# doesn't realise it has a body on the wire to consume, so the
1406
# only way to recover is to abandon the connection.
1408
'Server is too old for fast get_parent_map, reconnecting. '
1409
'(Upgrade the server to Bazaar 1.2 to avoid this)')
1411
# To avoid having to disconnect repeatedly, we keep track of the
1412
# fact the server doesn't understand remote methods added in 1.2.
1413
medium._remember_remote_is_before((1, 2))
1414
# Recurse just once and we should use the fallback code.
1415
return self._get_parent_map_rpc(keys)
1416
response_tuple, response_handler = response
1417
if response_tuple[0] not in ['ok']:
1418
response_handler.cancel_read_body()
1419
raise errors.UnexpectedSmartServerResponse(response_tuple)
1420
if response_tuple[0] == 'ok':
1421
coded = bz2.decompress(response_handler.read_body_bytes())
1423
# no revisions found
1425
lines = coded.split('\n')
1428
d = tuple(line.split())
1430
revision_graph[d[0]] = d[1:]
1433
if d[0].startswith('missing:'):
1435
self._unstacked_provider.note_missing_key(revid)
1437
# no parents - so give the Graph result
1439
revision_graph[d[0]] = (NULL_REVISION,)
1440
return revision_graph
1443
def get_signature_text(self, revision_id):
1445
return self._real_repository.get_signature_text(revision_id)
1448
def get_inventory_xml(self, revision_id):
1450
return self._real_repository.get_inventory_xml(revision_id)
1452
def deserialise_inventory(self, revision_id, xml):
1454
return self._real_repository.deserialise_inventory(revision_id, xml)
1456
def reconcile(self, other=None, thorough=False):
1458
return self._real_repository.reconcile(other=other, thorough=thorough)
1460
def all_revision_ids(self):
1462
return self._real_repository.all_revision_ids()
1465
def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1467
return self._real_repository.get_deltas_for_revisions(revisions,
1468
specific_fileids=specific_fileids)
1471
def get_revision_delta(self, revision_id, specific_fileids=None):
1473
return self._real_repository.get_revision_delta(revision_id,
1474
specific_fileids=specific_fileids)
1477
def revision_trees(self, revision_ids):
1479
return self._real_repository.revision_trees(revision_ids)
1482
def get_revision_reconcile(self, revision_id):
1484
return self._real_repository.get_revision_reconcile(revision_id)
1487
def check(self, revision_ids=None, callback_refs=None, check_repo=True):
1489
return self._real_repository.check(revision_ids=revision_ids,
1490
callback_refs=callback_refs, check_repo=check_repo)
1492
def copy_content_into(self, destination, revision_id=None):
1494
return self._real_repository.copy_content_into(
1495
destination, revision_id=revision_id)
1497
def _copy_repository_tarball(self, to_bzrdir, revision_id=None):
1498
# get a tarball of the remote repository, and copy from that into the
1500
from bzrlib import osutils
1502
# TODO: Maybe a progress bar while streaming the tarball?
1503
note("Copying repository content as tarball...")
1504
tar_file = self._get_tarball('bz2')
1505
if tar_file is None:
1507
destination = to_bzrdir.create_repository()
1509
tar = tarfile.open('repository', fileobj=tar_file,
1511
tmpdir = osutils.mkdtemp()
1513
_extract_tar(tar, tmpdir)
1514
tmp_bzrdir = BzrDir.open(tmpdir)
1515
tmp_repo = tmp_bzrdir.open_repository()
1516
tmp_repo.copy_content_into(destination, revision_id)
1518
osutils.rmtree(tmpdir)
1522
# TODO: Suggestion from john: using external tar is much faster than
1523
# python's tarfile library, but it may not work on windows.
1526
def inventories(self):
1527
"""Decorate the real repository for now.
1529
In the long term a full blown network facility is needed to
1530
avoid creating a real repository object locally.
1533
return self._real_repository.inventories
1536
def pack(self, hint=None):
1537
"""Compress the data within the repository.
1539
This is not currently implemented within the smart server.
1542
return self._real_repository.pack(hint=hint)
1545
def revisions(self):
1546
"""Decorate the real repository for now.
1548
In the short term this should become a real object to intercept graph
1551
In the long term a full blown network facility is needed.
1554
return self._real_repository.revisions
1556
def set_make_working_trees(self, new_value):
1558
new_value_str = "True"
1560
new_value_str = "False"
1561
path = self.bzrdir._path_for_remote_call(self._client)
1563
response = self._call(
1564
'Repository.set_make_working_trees', path, new_value_str)
1565
except errors.UnknownSmartMethod:
1567
self._real_repository.set_make_working_trees(new_value)
1569
if response[0] != 'ok':
1570
raise errors.UnexpectedSmartServerResponse(response)
1573
def signatures(self):
1574
"""Decorate the real repository for now.
1576
In the long term a full blown network facility is needed to avoid
1577
creating a real repository object locally.
1580
return self._real_repository.signatures
1583
def sign_revision(self, revision_id, gpg_strategy):
1585
return self._real_repository.sign_revision(revision_id, gpg_strategy)
1589
"""Decorate the real repository for now.
1591
In the long term a full blown network facility is needed to avoid
1592
creating a real repository object locally.
1595
return self._real_repository.texts
1598
def get_revisions(self, revision_ids):
1600
return self._real_repository.get_revisions(revision_ids)
1602
def supports_rich_root(self):
1603
return self._format.rich_root_data
1605
def iter_reverse_revision_history(self, revision_id):
1607
return self._real_repository.iter_reverse_revision_history(revision_id)
1610
def _serializer(self):
1611
return self._format._serializer
1613
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1615
return self._real_repository.store_revision_signature(
1616
gpg_strategy, plaintext, revision_id)
1618
def add_signature_text(self, revision_id, signature):
1620
return self._real_repository.add_signature_text(revision_id, signature)
1622
def has_signature_for_revision_id(self, revision_id):
1624
return self._real_repository.has_signature_for_revision_id(revision_id)
1626
def item_keys_introduced_by(self, revision_ids, _files_pb=None):
1628
return self._real_repository.item_keys_introduced_by(revision_ids,
1629
_files_pb=_files_pb)
1631
def revision_graph_can_have_wrong_parents(self):
1632
# The answer depends on the remote repo format.
1634
return self._real_repository.revision_graph_can_have_wrong_parents()
1636
def _find_inconsistent_revision_parents(self, revisions_iterator=None):
1638
return self._real_repository._find_inconsistent_revision_parents(
1641
def _check_for_inconsistent_revision_parents(self):
1643
return self._real_repository._check_for_inconsistent_revision_parents()
1645
def _make_parents_provider(self, other=None):
1646
providers = [self._unstacked_provider]
1647
if other is not None:
1648
providers.insert(0, other)
1649
providers.extend(r._make_parents_provider() for r in
1650
self._fallback_repositories)
1651
return graph.StackedParentsProvider(providers)
1653
def _serialise_search_recipe(self, recipe):
1654
"""Serialise a graph search recipe.
1656
:param recipe: A search recipe (start, stop, count).
1657
:return: Serialised bytes.
1659
start_keys = ' '.join(recipe[1])
1660
stop_keys = ' '.join(recipe[2])
1661
count = str(recipe[3])
1662
return '\n'.join((start_keys, stop_keys, count))
1664
def _serialise_search_result(self, search_result):
1665
if isinstance(search_result, graph.PendingAncestryResult):
1666
parts = ['ancestry-of']
1667
parts.extend(search_result.heads)
1669
recipe = search_result.get_recipe()
1670
parts = [recipe[0], self._serialise_search_recipe(recipe)]
1671
return '\n'.join(parts)
1674
path = self.bzrdir._path_for_remote_call(self._client)
1676
response = self._call('PackRepository.autopack', path)
1677
except errors.UnknownSmartMethod:
1679
self._real_repository._pack_collection.autopack()
1682
if response[0] != 'ok':
1683
raise errors.UnexpectedSmartServerResponse(response)
1686
class RemoteStreamSink(repository.StreamSink):
1688
def _insert_real(self, stream, src_format, resume_tokens):
1689
self.target_repo._ensure_real()
1690
sink = self.target_repo._real_repository._get_sink()
1691
result = sink.insert_stream(stream, src_format, resume_tokens)
1693
self.target_repo.autopack()
1696
def insert_stream(self, stream, src_format, resume_tokens):
1697
target = self.target_repo
1698
target._unstacked_provider.missing_keys.clear()
1699
candidate_calls = [('Repository.insert_stream_1.19', (1, 19))]
1700
if target._lock_token:
1701
candidate_calls.append(('Repository.insert_stream_locked', (1, 14)))
1702
lock_args = (target._lock_token or '',)
1704
candidate_calls.append(('Repository.insert_stream', (1, 13)))
1706
client = target._client
1707
medium = client._medium
1708
path = target.bzrdir._path_for_remote_call(client)
1709
# Probe for the verb to use with an empty stream before sending the
1710
# real stream to it. We do this both to avoid the risk of sending a
1711
# large request that is then rejected, and because we don't want to
1712
# implement a way to buffer, rewind, or restart the stream.
1714
for verb, required_version in candidate_calls:
1715
if medium._is_remote_before(required_version):
1718
# We've already done the probing (and set _is_remote_before) on
1719
# a previous insert.
1722
byte_stream = smart_repo._stream_to_byte_stream([], src_format)
1724
response = client.call_with_body_stream(
1725
(verb, path, '') + lock_args, byte_stream)
1726
except errors.UnknownSmartMethod:
1727
medium._remember_remote_is_before(required_version)
1733
return self._insert_real(stream, src_format, resume_tokens)
1734
self._last_inv_record = None
1735
self._last_substream = None
1736
if required_version < (1, 19):
1737
# Remote side doesn't support inventory deltas. Wrap the stream to
1738
# make sure we don't send any. If the stream contains inventory
1739
# deltas we'll interrupt the smart insert_stream request and
1741
stream = self._stop_stream_if_inventory_delta(stream)
1742
byte_stream = smart_repo._stream_to_byte_stream(
1744
resume_tokens = ' '.join(resume_tokens)
1745
response = client.call_with_body_stream(
1746
(verb, path, resume_tokens) + lock_args, byte_stream)
1747
if response[0][0] not in ('ok', 'missing-basis'):
1748
raise errors.UnexpectedSmartServerResponse(response)
1749
if self._last_substream is not None:
1750
# The stream included an inventory-delta record, but the remote
1751
# side isn't new enough to support them. So we need to send the
1752
# rest of the stream via VFS.
1753
return self._resume_stream_with_vfs(response, src_format)
1754
if response[0][0] == 'missing-basis':
1755
tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1756
resume_tokens = tokens
1757
return resume_tokens, set(missing_keys)
1759
self.target_repo.refresh_data()
1762
def _resume_stream_with_vfs(self, response, src_format):
1763
"""Resume sending a stream via VFS, first resending the record and
1764
substream that couldn't be sent via an insert_stream verb.
1766
if response[0][0] == 'missing-basis':
1767
tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1768
# Ignore missing_keys, we haven't finished inserting yet
1771
def resume_substream():
1772
# Yield the substream that was interrupted.
1773
for record in self._last_substream:
1775
self._last_substream = None
1776
def resume_stream():
1777
# Finish sending the interrupted substream
1778
yield ('inventory-deltas', resume_substream())
1779
# Then simply continue sending the rest of the stream.
1780
for substream_kind, substream in self._last_stream:
1781
yield substream_kind, substream
1782
return self._insert_real(resume_stream(), src_format, tokens)
1784
def _stop_stream_if_inventory_delta(self, stream):
1785
"""Normally this just lets the original stream pass-through unchanged.
1787
However if any 'inventory-deltas' substream occurs it will stop
1788
streaming, and store the interrupted substream and stream in
1789
self._last_substream and self._last_stream so that the stream can be
1790
resumed by _resume_stream_with_vfs.
1793
stream_iter = iter(stream)
1794
for substream_kind, substream in stream_iter:
1795
if substream_kind == 'inventory-deltas':
1796
self._last_substream = substream
1797
self._last_stream = stream_iter
1800
yield substream_kind, substream
1803
class RemoteStreamSource(repository.StreamSource):
1804
"""Stream data from a remote server."""
1806
def get_stream(self, search):
1807
if (self.from_repository._fallback_repositories and
1808
self.to_format._fetch_order == 'topological'):
1809
return self._real_stream(self.from_repository, search)
1812
repos = [self.from_repository]
1818
repos.extend(repo._fallback_repositories)
1819
sources.append(repo)
1820
return self.missing_parents_chain(search, sources)
1822
def get_stream_for_missing_keys(self, missing_keys):
1823
self.from_repository._ensure_real()
1824
real_repo = self.from_repository._real_repository
1825
real_source = real_repo._get_source(self.to_format)
1826
return real_source.get_stream_for_missing_keys(missing_keys)
1828
def _real_stream(self, repo, search):
1829
"""Get a stream for search from repo.
1831
This never called RemoteStreamSource.get_stream, and is a heler
1832
for RemoteStreamSource._get_stream to allow getting a stream
1833
reliably whether fallback back because of old servers or trying
1834
to stream from a non-RemoteRepository (which the stacked support
1837
source = repo._get_source(self.to_format)
1838
if isinstance(source, RemoteStreamSource):
1840
source = repo._real_repository._get_source(self.to_format)
1841
return source.get_stream(search)
1843
def _get_stream(self, repo, search):
1844
"""Core worker to get a stream from repo for search.
1846
This is used by both get_stream and the stacking support logic. It
1847
deliberately gets a stream for repo which does not need to be
1848
self.from_repository. In the event that repo is not Remote, or
1849
cannot do a smart stream, a fallback is made to the generic
1850
repository._get_stream() interface, via self._real_stream.
1852
In the event of stacking, streams from _get_stream will not
1853
contain all the data for search - this is normal (see get_stream).
1855
:param repo: A repository.
1856
:param search: A search.
1858
# Fallbacks may be non-smart
1859
if not isinstance(repo, RemoteRepository):
1860
return self._real_stream(repo, search)
1861
client = repo._client
1862
medium = client._medium
1863
path = repo.bzrdir._path_for_remote_call(client)
1864
search_bytes = repo._serialise_search_result(search)
1865
args = (path, self.to_format.network_name())
1867
('Repository.get_stream_1.19', (1, 19)),
1868
('Repository.get_stream', (1, 13))]
1870
for verb, version in candidate_verbs:
1871
if medium._is_remote_before(version):
1874
response = repo._call_with_body_bytes_expecting_body(
1875
verb, args, search_bytes)
1876
except errors.UnknownSmartMethod:
1877
medium._remember_remote_is_before(version)
1879
response_tuple, response_handler = response
1883
return self._real_stream(repo, search)
1884
if response_tuple[0] != 'ok':
1885
raise errors.UnexpectedSmartServerResponse(response_tuple)
1886
byte_stream = response_handler.read_streamed_body()
1887
src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
1888
if src_format.network_name() != repo._format.network_name():
1889
raise AssertionError(
1890
"Mismatched RemoteRepository and stream src %r, %r" % (
1891
src_format.network_name(), repo._format.network_name()))
1894
def missing_parents_chain(self, search, sources):
1895
"""Chain multiple streams together to handle stacking.
1897
:param search: The overall search to satisfy with streams.
1898
:param sources: A list of Repository objects to query.
1900
self.serialiser = self.to_format._serializer
1901
self.seen_revs = set()
1902
self.referenced_revs = set()
1903
# If there are heads in the search, or the key count is > 0, we are not
1905
while not search.is_empty() and len(sources) > 1:
1906
source = sources.pop(0)
1907
stream = self._get_stream(source, search)
1908
for kind, substream in stream:
1909
if kind != 'revisions':
1910
yield kind, substream
1912
yield kind, self.missing_parents_rev_handler(substream)
1913
search = search.refine(self.seen_revs, self.referenced_revs)
1914
self.seen_revs = set()
1915
self.referenced_revs = set()
1916
if not search.is_empty():
1917
for kind, stream in self._get_stream(sources[0], search):
1920
def missing_parents_rev_handler(self, substream):
1921
for content in substream:
1922
revision_bytes = content.get_bytes_as('fulltext')
1923
revision = self.serialiser.read_revision_from_string(revision_bytes)
1924
self.seen_revs.add(content.key[-1])
1925
self.referenced_revs.update(revision.parent_ids)
1929
class RemoteBranchLockableFiles(LockableFiles):
1930
"""A 'LockableFiles' implementation that talks to a smart server.
1932
This is not a public interface class.
1935
def __init__(self, bzrdir, _client):
1936
self.bzrdir = bzrdir
1937
self._client = _client
1938
self._need_find_modes = True
1939
LockableFiles.__init__(
1940
self, bzrdir.get_branch_transport(None),
1941
'lock', lockdir.LockDir)
1943
def _find_modes(self):
1944
# RemoteBranches don't let the client set the mode of control files.
1945
self._dir_mode = None
1946
self._file_mode = None
1949
class RemoteBranchFormat(branch.BranchFormat):
1951
def __init__(self, network_name=None):
1952
super(RemoteBranchFormat, self).__init__()
1953
self._matchingbzrdir = RemoteBzrDirFormat()
1954
self._matchingbzrdir.set_branch_format(self)
1955
self._custom_format = None
1956
self._network_name = network_name
1958
def __eq__(self, other):
1959
return (isinstance(other, RemoteBranchFormat) and
1960
self.__dict__ == other.__dict__)
1962
def _ensure_real(self):
1963
if self._custom_format is None:
1964
self._custom_format = branch.network_format_registry.get(
1967
def get_format_description(self):
1968
return 'Remote BZR Branch'
1970
def network_name(self):
1971
return self._network_name
1973
def open(self, a_bzrdir, ignore_fallbacks=False):
1974
return a_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
1976
def _vfs_initialize(self, a_bzrdir):
1977
# Initialisation when using a local bzrdir object, or a non-vfs init
1978
# method is not available on the server.
1979
# self._custom_format is always set - the start of initialize ensures
1981
if isinstance(a_bzrdir, RemoteBzrDir):
1982
a_bzrdir._ensure_real()
1983
result = self._custom_format.initialize(a_bzrdir._real_bzrdir)
1985
# We assume the bzrdir is parameterised; it may not be.
1986
result = self._custom_format.initialize(a_bzrdir)
1987
if (isinstance(a_bzrdir, RemoteBzrDir) and
1988
not isinstance(result, RemoteBranch)):
1989
result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result)
1992
def initialize(self, a_bzrdir):
1993
# 1) get the network name to use.
1994
if self._custom_format:
1995
network_name = self._custom_format.network_name()
1997
# Select the current bzrlib default and ask for that.
1998
reference_bzrdir_format = bzrdir.format_registry.get('default')()
1999
reference_format = reference_bzrdir_format.get_branch_format()
2000
self._custom_format = reference_format
2001
network_name = reference_format.network_name()
2002
# Being asked to create on a non RemoteBzrDir:
2003
if not isinstance(a_bzrdir, RemoteBzrDir):
2004
return self._vfs_initialize(a_bzrdir)
2005
medium = a_bzrdir._client._medium
2006
if medium._is_remote_before((1, 13)):
2007
return self._vfs_initialize(a_bzrdir)
2008
# Creating on a remote bzr dir.
2009
# 2) try direct creation via RPC
2010
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2011
verb = 'BzrDir.create_branch'
2013
response = a_bzrdir._call(verb, path, network_name)
2014
except errors.UnknownSmartMethod:
2015
# Fallback - use vfs methods
2016
medium._remember_remote_is_before((1, 13))
2017
return self._vfs_initialize(a_bzrdir)
2018
if response[0] != 'ok':
2019
raise errors.UnexpectedSmartServerResponse(response)
2020
# Turn the response into a RemoteRepository object.
2021
format = RemoteBranchFormat(network_name=response[1])
2022
repo_format = response_tuple_to_repo_format(response[3:])
2023
if response[2] == '':
2024
repo_bzrdir = a_bzrdir
2026
repo_bzrdir = RemoteBzrDir(
2027
a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
2029
remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2030
remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2031
format=format, setup_stacking=False)
2032
# XXX: We know this is a new branch, so it must have revno 0, revid
2033
# NULL_REVISION. Creating the branch locked would make this be unable
2034
# to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2035
remote_branch._last_revision_info_cache = 0, NULL_REVISION
2036
return remote_branch
2038
def make_tags(self, branch):
2040
return self._custom_format.make_tags(branch)
2042
def supports_tags(self):
2043
# Remote branches might support tags, but we won't know until we
2044
# access the real remote branch.
2046
return self._custom_format.supports_tags()
2048
def supports_stacking(self):
2050
return self._custom_format.supports_stacking()
2052
def supports_set_append_revisions_only(self):
2054
return self._custom_format.supports_set_append_revisions_only()
2057
class RemoteBranch(branch.Branch, _RpcHelper):
2058
"""Branch stored on a server accessed by HPSS RPC.
2060
At the moment most operations are mapped down to simple file operations.
2063
def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2064
_client=None, format=None, setup_stacking=True):
2065
"""Create a RemoteBranch instance.
2067
:param real_branch: An optional local implementation of the branch
2068
format, usually accessing the data via the VFS.
2069
:param _client: Private parameter for testing.
2070
:param format: A RemoteBranchFormat object, None to create one
2071
automatically. If supplied it should have a network_name already
2073
:param setup_stacking: If True make an RPC call to determine the
2074
stacked (or not) status of the branch. If False assume the branch
2077
# We intentionally don't call the parent class's __init__, because it
2078
# will try to assign to self.tags, which is a property in this subclass.
2079
# And the parent's __init__ doesn't do much anyway.
2080
self.bzrdir = remote_bzrdir
2081
if _client is not None:
2082
self._client = _client
2084
self._client = remote_bzrdir._client
2085
self.repository = remote_repository
2086
if real_branch is not None:
2087
self._real_branch = real_branch
2088
# Give the remote repository the matching real repo.
2089
real_repo = self._real_branch.repository
2090
if isinstance(real_repo, RemoteRepository):
2091
real_repo._ensure_real()
2092
real_repo = real_repo._real_repository
2093
self.repository._set_real_repository(real_repo)
2094
# Give the branch the remote repository to let fast-pathing happen.
2095
self._real_branch.repository = self.repository
2097
self._real_branch = None
2098
# Fill out expected attributes of branch for bzrlib API users.
2099
self._clear_cached_state()
2100
self.base = self.bzrdir.root_transport.base
2101
self._control_files = None
2102
self._lock_mode = None
2103
self._lock_token = None
2104
self._repo_lock_token = None
2105
self._lock_count = 0
2106
self._leave_lock = False
2107
# Setup a format: note that we cannot call _ensure_real until all the
2108
# attributes above are set: This code cannot be moved higher up in this
2111
self._format = RemoteBranchFormat()
2112
if real_branch is not None:
2113
self._format._network_name = \
2114
self._real_branch._format.network_name()
2116
self._format = format
2117
# when we do _ensure_real we may need to pass ignore_fallbacks to the
2118
# branch.open_branch method.
2119
self._real_ignore_fallbacks = not setup_stacking
2120
if not self._format._network_name:
2121
# Did not get from open_branchV2 - old server.
2123
self._format._network_name = \
2124
self._real_branch._format.network_name()
2125
self.tags = self._format.make_tags(self)
2126
# The base class init is not called, so we duplicate this:
2127
hooks = branch.Branch.hooks['open']
2130
self._is_stacked = False
2132
self._setup_stacking()
2134
def _setup_stacking(self):
2135
# configure stacking into the remote repository, by reading it from
2138
fallback_url = self.get_stacked_on_url()
2139
except (errors.NotStacked, errors.UnstackableBranchFormat,
2140
errors.UnstackableRepositoryFormat), e:
2142
self._is_stacked = True
2143
self._activate_fallback_location(fallback_url)
2145
def _get_config(self):
2146
return RemoteBranchConfig(self)
2148
def _get_real_transport(self):
2149
# if we try vfs access, return the real branch's vfs transport
2151
return self._real_branch._transport
2153
_transport = property(_get_real_transport)
2156
return "%s(%s)" % (self.__class__.__name__, self.base)
2160
def _ensure_real(self):
2161
"""Ensure that there is a _real_branch set.
2163
Used before calls to self._real_branch.
2165
if self._real_branch is None:
2166
if not vfs.vfs_enabled():
2167
raise AssertionError('smart server vfs must be enabled '
2168
'to use vfs implementation')
2169
self.bzrdir._ensure_real()
2170
self._real_branch = self.bzrdir._real_bzrdir.open_branch(
2171
ignore_fallbacks=self._real_ignore_fallbacks)
2172
if self.repository._real_repository is None:
2173
# Give the remote repository the matching real repo.
2174
real_repo = self._real_branch.repository
2175
if isinstance(real_repo, RemoteRepository):
2176
real_repo._ensure_real()
2177
real_repo = real_repo._real_repository
2178
self.repository._set_real_repository(real_repo)
2179
# Give the real branch the remote repository to let fast-pathing
2181
self._real_branch.repository = self.repository
2182
if self._lock_mode == 'r':
2183
self._real_branch.lock_read()
2184
elif self._lock_mode == 'w':
2185
self._real_branch.lock_write(token=self._lock_token)
2187
def _translate_error(self, err, **context):
2188
self.repository._translate_error(err, branch=self, **context)
2190
def _clear_cached_state(self):
2191
super(RemoteBranch, self)._clear_cached_state()
2192
if self._real_branch is not None:
2193
self._real_branch._clear_cached_state()
2195
def _clear_cached_state_of_remote_branch_only(self):
2196
"""Like _clear_cached_state, but doesn't clear the cache of
2199
This is useful when falling back to calling a method of
2200
self._real_branch that changes state. In that case the underlying
2201
branch changes, so we need to invalidate this RemoteBranch's cache of
2202
it. However, there's no need to invalidate the _real_branch's cache
2203
too, in fact doing so might harm performance.
2205
super(RemoteBranch, self)._clear_cached_state()
2208
def control_files(self):
2209
# Defer actually creating RemoteBranchLockableFiles until its needed,
2210
# because it triggers an _ensure_real that we otherwise might not need.
2211
if self._control_files is None:
2212
self._control_files = RemoteBranchLockableFiles(
2213
self.bzrdir, self._client)
2214
return self._control_files
2216
def _get_checkout_format(self):
2218
return self._real_branch._get_checkout_format()
2220
def get_physical_lock_status(self):
2221
"""See Branch.get_physical_lock_status()."""
2222
# should be an API call to the server, as branches must be lockable.
2224
return self._real_branch.get_physical_lock_status()
2226
def get_stacked_on_url(self):
2227
"""Get the URL this branch is stacked against.
2229
:raises NotStacked: If the branch is not stacked.
2230
:raises UnstackableBranchFormat: If the branch does not support
2232
:raises UnstackableRepositoryFormat: If the repository does not support
2236
# there may not be a repository yet, so we can't use
2237
# self._translate_error, so we can't use self._call either.
2238
response = self._client.call('Branch.get_stacked_on_url',
2239
self._remote_path())
2240
except errors.ErrorFromSmartServer, err:
2241
# there may not be a repository yet, so we can't call through
2242
# its _translate_error
2243
_translate_error(err, branch=self)
2244
except errors.UnknownSmartMethod, err:
2246
return self._real_branch.get_stacked_on_url()
2247
if response[0] != 'ok':
2248
raise errors.UnexpectedSmartServerResponse(response)
2251
def set_stacked_on_url(self, url):
2252
branch.Branch.set_stacked_on_url(self, url)
2254
self._is_stacked = False
2256
self._is_stacked = True
2258
def _vfs_get_tags_bytes(self):
2260
return self._real_branch._get_tags_bytes()
2262
def _get_tags_bytes(self):
2263
medium = self._client._medium
2264
if medium._is_remote_before((1, 13)):
2265
return self._vfs_get_tags_bytes()
2267
response = self._call('Branch.get_tags_bytes', self._remote_path())
2268
except errors.UnknownSmartMethod:
2269
medium._remember_remote_is_before((1, 13))
2270
return self._vfs_get_tags_bytes()
2273
def _vfs_set_tags_bytes(self, bytes):
2275
return self._real_branch._set_tags_bytes(bytes)
2277
def _set_tags_bytes(self, bytes):
2278
medium = self._client._medium
2279
if medium._is_remote_before((1, 18)):
2280
self._vfs_set_tags_bytes(bytes)
2283
self._remote_path(), self._lock_token, self._repo_lock_token)
2284
response = self._call_with_body_bytes(
2285
'Branch.set_tags_bytes', args, bytes)
2286
except errors.UnknownSmartMethod:
2287
medium._remember_remote_is_before((1, 18))
2288
self._vfs_set_tags_bytes(bytes)
2290
def lock_read(self):
2291
self.repository.lock_read()
2292
if not self._lock_mode:
2293
self._lock_mode = 'r'
2294
self._lock_count = 1
2295
if self._real_branch is not None:
2296
self._real_branch.lock_read()
2298
self._lock_count += 1
2300
def _remote_lock_write(self, token):
2302
branch_token = repo_token = ''
2304
branch_token = token
2305
repo_token = self.repository.lock_write()
2306
self.repository.unlock()
2307
err_context = {'token': token}
2308
response = self._call(
2309
'Branch.lock_write', self._remote_path(), branch_token,
2310
repo_token or '', **err_context)
2311
if response[0] != 'ok':
2312
raise errors.UnexpectedSmartServerResponse(response)
2313
ok, branch_token, repo_token = response
2314
return branch_token, repo_token
2316
def lock_write(self, token=None):
2317
if not self._lock_mode:
2318
# Lock the branch and repo in one remote call.
2319
remote_tokens = self._remote_lock_write(token)
2320
self._lock_token, self._repo_lock_token = remote_tokens
2321
if not self._lock_token:
2322
raise SmartProtocolError('Remote server did not return a token!')
2323
# Tell the self.repository object that it is locked.
2324
self.repository.lock_write(
2325
self._repo_lock_token, _skip_rpc=True)
2327
if self._real_branch is not None:
2328
self._real_branch.lock_write(token=self._lock_token)
2329
if token is not None:
2330
self._leave_lock = True
2332
self._leave_lock = False
2333
self._lock_mode = 'w'
2334
self._lock_count = 1
2335
elif self._lock_mode == 'r':
2336
raise errors.ReadOnlyTransaction
2338
if token is not None:
2339
# A token was given to lock_write, and we're relocking, so
2340
# check that the given token actually matches the one we
2342
if token != self._lock_token:
2343
raise errors.TokenMismatch(token, self._lock_token)
2344
self._lock_count += 1
2345
# Re-lock the repository too.
2346
self.repository.lock_write(self._repo_lock_token)
2347
return self._lock_token or None
2349
def _unlock(self, branch_token, repo_token):
2350
err_context = {'token': str((branch_token, repo_token))}
2351
response = self._call(
2352
'Branch.unlock', self._remote_path(), branch_token,
2353
repo_token or '', **err_context)
2354
if response == ('ok',):
2356
raise errors.UnexpectedSmartServerResponse(response)
2360
self._lock_count -= 1
2361
if not self._lock_count:
2362
self._clear_cached_state()
2363
mode = self._lock_mode
2364
self._lock_mode = None
2365
if self._real_branch is not None:
2366
if (not self._leave_lock and mode == 'w' and
2367
self._repo_lock_token):
2368
# If this RemoteBranch will remove the physical lock
2369
# for the repository, make sure the _real_branch
2370
# doesn't do it first. (Because the _real_branch's
2371
# repository is set to be the RemoteRepository.)
2372
self._real_branch.repository.leave_lock_in_place()
2373
self._real_branch.unlock()
2375
# Only write-locked branched need to make a remote method
2376
# call to perform the unlock.
2378
if not self._lock_token:
2379
raise AssertionError('Locked, but no token!')
2380
branch_token = self._lock_token
2381
repo_token = self._repo_lock_token
2382
self._lock_token = None
2383
self._repo_lock_token = None
2384
if not self._leave_lock:
2385
self._unlock(branch_token, repo_token)
2387
self.repository.unlock()
2389
def break_lock(self):
2391
return self._real_branch.break_lock()
2393
def leave_lock_in_place(self):
2394
if not self._lock_token:
2395
raise NotImplementedError(self.leave_lock_in_place)
2396
self._leave_lock = True
2398
def dont_leave_lock_in_place(self):
2399
if not self._lock_token:
2400
raise NotImplementedError(self.dont_leave_lock_in_place)
2401
self._leave_lock = False
2403
def get_rev_id(self, revno, history=None):
2405
return _mod_revision.NULL_REVISION
2406
last_revision_info = self.last_revision_info()
2407
ok, result = self.repository.get_rev_id_for_revno(
2408
revno, last_revision_info)
2411
missing_parent = result[1]
2412
# Either the revision named by the server is missing, or its parent
2413
# is. Call get_parent_map to determine which, so that we report a
2415
parent_map = self.repository.get_parent_map([missing_parent])
2416
if missing_parent in parent_map:
2417
missing_parent = parent_map[missing_parent]
2418
raise errors.RevisionNotPresent(missing_parent, self.repository)
2420
def _last_revision_info(self):
2421
response = self._call('Branch.last_revision_info', self._remote_path())
2422
if response[0] != 'ok':
2423
raise SmartProtocolError('unexpected response code %s' % (response,))
2424
revno = int(response[1])
2425
last_revision = response[2]
2426
return (revno, last_revision)
2428
def _gen_revision_history(self):
2429
"""See Branch._gen_revision_history()."""
2430
if self._is_stacked:
2432
return self._real_branch._gen_revision_history()
2433
response_tuple, response_handler = self._call_expecting_body(
2434
'Branch.revision_history', self._remote_path())
2435
if response_tuple[0] != 'ok':
2436
raise errors.UnexpectedSmartServerResponse(response_tuple)
2437
result = response_handler.read_body_bytes().split('\x00')
2442
def _remote_path(self):
2443
return self.bzrdir._path_for_remote_call(self._client)
2445
def _set_last_revision_descendant(self, revision_id, other_branch,
2446
allow_diverged=False, allow_overwrite_descendant=False):
2447
# This performs additional work to meet the hook contract; while its
2448
# undesirable, we have to synthesise the revno to call the hook, and
2449
# not calling the hook is worse as it means changes can't be prevented.
2450
# Having calculated this though, we can't just call into
2451
# set_last_revision_info as a simple call, because there is a set_rh
2452
# hook that some folk may still be using.
2453
old_revno, old_revid = self.last_revision_info()
2454
history = self._lefthand_history(revision_id)
2455
self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2456
err_context = {'other_branch': other_branch}
2457
response = self._call('Branch.set_last_revision_ex',
2458
self._remote_path(), self._lock_token, self._repo_lock_token,
2459
revision_id, int(allow_diverged), int(allow_overwrite_descendant),
2461
self._clear_cached_state()
2462
if len(response) != 3 and response[0] != 'ok':
2463
raise errors.UnexpectedSmartServerResponse(response)
2464
new_revno, new_revision_id = response[1:]
2465
self._last_revision_info_cache = new_revno, new_revision_id
2466
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2467
if self._real_branch is not None:
2468
cache = new_revno, new_revision_id
2469
self._real_branch._last_revision_info_cache = cache
2471
def _set_last_revision(self, revision_id):
2472
old_revno, old_revid = self.last_revision_info()
2473
# This performs additional work to meet the hook contract; while its
2474
# undesirable, we have to synthesise the revno to call the hook, and
2475
# not calling the hook is worse as it means changes can't be prevented.
2476
# Having calculated this though, we can't just call into
2477
# set_last_revision_info as a simple call, because there is a set_rh
2478
# hook that some folk may still be using.
2479
history = self._lefthand_history(revision_id)
2480
self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2481
self._clear_cached_state()
2482
response = self._call('Branch.set_last_revision',
2483
self._remote_path(), self._lock_token, self._repo_lock_token,
2485
if response != ('ok',):
2486
raise errors.UnexpectedSmartServerResponse(response)
2487
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2490
def set_revision_history(self, rev_history):
2491
# Send just the tip revision of the history; the server will generate
2492
# the full history from that. If the revision doesn't exist in this
2493
# branch, NoSuchRevision will be raised.
2494
if rev_history == []:
2497
rev_id = rev_history[-1]
2498
self._set_last_revision(rev_id)
2499
for hook in branch.Branch.hooks['set_rh']:
2500
hook(self, rev_history)
2501
self._cache_revision_history(rev_history)
2503
def _get_parent_location(self):
2504
medium = self._client._medium
2505
if medium._is_remote_before((1, 13)):
2506
return self._vfs_get_parent_location()
2508
response = self._call('Branch.get_parent', self._remote_path())
2509
except errors.UnknownSmartMethod:
2510
medium._remember_remote_is_before((1, 13))
2511
return self._vfs_get_parent_location()
2512
if len(response) != 1:
2513
raise errors.UnexpectedSmartServerResponse(response)
2514
parent_location = response[0]
2515
if parent_location == '':
2517
return parent_location
2519
def _vfs_get_parent_location(self):
2521
return self._real_branch._get_parent_location()
2523
def _set_parent_location(self, url):
2524
medium = self._client._medium
2525
if medium._is_remote_before((1, 15)):
2526
return self._vfs_set_parent_location(url)
2528
call_url = url or ''
2529
if type(call_url) is not str:
2530
raise AssertionError('url must be a str or None (%s)' % url)
2531
response = self._call('Branch.set_parent_location',
2532
self._remote_path(), self._lock_token, self._repo_lock_token,
2534
except errors.UnknownSmartMethod:
2535
medium._remember_remote_is_before((1, 15))
2536
return self._vfs_set_parent_location(url)
2538
raise errors.UnexpectedSmartServerResponse(response)
2540
def _vfs_set_parent_location(self, url):
2542
return self._real_branch._set_parent_location(url)
2545
def pull(self, source, overwrite=False, stop_revision=None,
2547
self._clear_cached_state_of_remote_branch_only()
2549
return self._real_branch.pull(
2550
source, overwrite=overwrite, stop_revision=stop_revision,
2551
_override_hook_target=self, **kwargs)
2554
def push(self, target, overwrite=False, stop_revision=None):
2556
return self._real_branch.push(
2557
target, overwrite=overwrite, stop_revision=stop_revision,
2558
_override_hook_source_branch=self)
2560
def is_locked(self):
2561
return self._lock_count >= 1
2564
def revision_id_to_revno(self, revision_id):
2566
return self._real_branch.revision_id_to_revno(revision_id)
2569
def set_last_revision_info(self, revno, revision_id):
2570
# XXX: These should be returned by the set_last_revision_info verb
2571
old_revno, old_revid = self.last_revision_info()
2572
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2573
revision_id = ensure_null(revision_id)
2575
response = self._call('Branch.set_last_revision_info',
2576
self._remote_path(), self._lock_token, self._repo_lock_token,
2577
str(revno), revision_id)
2578
except errors.UnknownSmartMethod:
2580
self._clear_cached_state_of_remote_branch_only()
2581
self._real_branch.set_last_revision_info(revno, revision_id)
2582
self._last_revision_info_cache = revno, revision_id
2584
if response == ('ok',):
2585
self._clear_cached_state()
2586
self._last_revision_info_cache = revno, revision_id
2587
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2588
# Update the _real_branch's cache too.
2589
if self._real_branch is not None:
2590
cache = self._last_revision_info_cache
2591
self._real_branch._last_revision_info_cache = cache
2593
raise errors.UnexpectedSmartServerResponse(response)
2596
def generate_revision_history(self, revision_id, last_rev=None,
2598
medium = self._client._medium
2599
if not medium._is_remote_before((1, 6)):
2600
# Use a smart method for 1.6 and above servers
2602
self._set_last_revision_descendant(revision_id, other_branch,
2603
allow_diverged=True, allow_overwrite_descendant=True)
2605
except errors.UnknownSmartMethod:
2606
medium._remember_remote_is_before((1, 6))
2607
self._clear_cached_state_of_remote_branch_only()
2608
self.set_revision_history(self._lefthand_history(revision_id,
2609
last_rev=last_rev,other_branch=other_branch))
2611
def set_push_location(self, location):
2613
return self._real_branch.set_push_location(location)
2616
class RemoteConfig(object):
2617
"""A Config that reads and writes from smart verbs.
2619
It is a low-level object that considers config data to be name/value pairs
2620
that may be associated with a section. Assigning meaning to the these
2621
values is done at higher levels like bzrlib.config.TreeConfig.
2624
def get_option(self, name, section=None, default=None):
2625
"""Return the value associated with a named option.
2627
:param name: The name of the value
2628
:param section: The section the option is in (if any)
2629
:param default: The value to return if the value is not set
2630
:return: The value or default value
2633
configobj = self._get_configobj()
2635
section_obj = configobj
2638
section_obj = configobj[section]
2641
return section_obj.get(name, default)
2642
except errors.UnknownSmartMethod:
2643
return self._vfs_get_option(name, section, default)
2645
def _response_to_configobj(self, response):
2646
if len(response[0]) and response[0][0] != 'ok':
2647
raise errors.UnexpectedSmartServerResponse(response)
2648
lines = response[1].read_body_bytes().splitlines()
2649
return config.ConfigObj(lines, encoding='utf-8')
2652
class RemoteBranchConfig(RemoteConfig):
2653
"""A RemoteConfig for Branches."""
2655
def __init__(self, branch):
2656
self._branch = branch
2658
def _get_configobj(self):
2659
path = self._branch._remote_path()
2660
response = self._branch._client.call_expecting_body(
2661
'Branch.get_config_file', path)
2662
return self._response_to_configobj(response)
2664
def set_option(self, value, name, section=None):
2665
"""Set the value associated with a named option.
2667
:param value: The value to set
2668
:param name: The name of the value to set
2669
:param section: The section the option is in (if any)
2671
medium = self._branch._client._medium
2672
if medium._is_remote_before((1, 14)):
2673
return self._vfs_set_option(value, name, section)
2675
path = self._branch._remote_path()
2676
response = self._branch._client.call('Branch.set_config_option',
2677
path, self._branch._lock_token, self._branch._repo_lock_token,
2678
value.encode('utf8'), name, section or '')
2679
except errors.UnknownSmartMethod:
2680
medium._remember_remote_is_before((1, 14))
2681
return self._vfs_set_option(value, name, section)
2683
raise errors.UnexpectedSmartServerResponse(response)
2685
def _real_object(self):
2686
self._branch._ensure_real()
2687
return self._branch._real_branch
2689
def _vfs_set_option(self, value, name, section=None):
2690
return self._real_object()._get_config().set_option(
2691
value, name, section)
2694
class RemoteBzrDirConfig(RemoteConfig):
2695
"""A RemoteConfig for BzrDirs."""
2697
def __init__(self, bzrdir):
2698
self._bzrdir = bzrdir
2700
def _get_configobj(self):
2701
medium = self._bzrdir._client._medium
2702
verb = 'BzrDir.get_config_file'
2703
if medium._is_remote_before((1, 15)):
2704
raise errors.UnknownSmartMethod(verb)
2705
path = self._bzrdir._path_for_remote_call(self._bzrdir._client)
2706
response = self._bzrdir._call_expecting_body(
2708
return self._response_to_configobj(response)
2710
def _vfs_get_option(self, name, section, default):
2711
return self._real_object()._get_config().get_option(
2712
name, section, default)
2714
def set_option(self, value, name, section=None):
2715
"""Set the value associated with a named option.
2717
:param value: The value to set
2718
:param name: The name of the value to set
2719
:param section: The section the option is in (if any)
2721
return self._real_object()._get_config().set_option(
2722
value, name, section)
2724
def _real_object(self):
2725
self._bzrdir._ensure_real()
2726
return self._bzrdir._real_bzrdir
2730
def _extract_tar(tar, to_dir):
2731
"""Extract all the contents of a tarfile object.
2733
A replacement for extractall, which is not present in python2.4
2736
tar.extract(tarinfo, to_dir)
2739
def _translate_error(err, **context):
2740
"""Translate an ErrorFromSmartServer into a more useful error.
2742
Possible context keys:
2750
If the error from the server doesn't match a known pattern, then
2751
UnknownErrorFromSmartServer is raised.
2755
return context[name]
2756
except KeyError, key_err:
2757
mutter('Missing key %r in context %r', key_err.args[0], context)
2760
"""Get the path from the context if present, otherwise use first error
2764
return context['path']
2765
except KeyError, key_err:
2767
return err.error_args[0]
2768
except IndexError, idx_err:
2770
'Missing key %r in context %r', key_err.args[0], context)
2773
if err.error_verb == 'NoSuchRevision':
2774
raise NoSuchRevision(find('branch'), err.error_args[0])
2775
elif err.error_verb == 'nosuchrevision':
2776
raise NoSuchRevision(find('repository'), err.error_args[0])
2777
elif err.error_tuple == ('nobranch',):
2778
raise errors.NotBranchError(path=find('bzrdir').root_transport.base)
2779
elif err.error_verb == 'norepository':
2780
raise errors.NoRepositoryPresent(find('bzrdir'))
2781
elif err.error_verb == 'LockContention':
2782
raise errors.LockContention('(remote lock)')
2783
elif err.error_verb == 'UnlockableTransport':
2784
raise errors.UnlockableTransport(find('bzrdir').root_transport)
2785
elif err.error_verb == 'LockFailed':
2786
raise errors.LockFailed(err.error_args[0], err.error_args[1])
2787
elif err.error_verb == 'TokenMismatch':
2788
raise errors.TokenMismatch(find('token'), '(remote token)')
2789
elif err.error_verb == 'Diverged':
2790
raise errors.DivergedBranches(find('branch'), find('other_branch'))
2791
elif err.error_verb == 'TipChangeRejected':
2792
raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
2793
elif err.error_verb == 'UnstackableBranchFormat':
2794
raise errors.UnstackableBranchFormat(*err.error_args)
2795
elif err.error_verb == 'UnstackableRepositoryFormat':
2796
raise errors.UnstackableRepositoryFormat(*err.error_args)
2797
elif err.error_verb == 'NotStacked':
2798
raise errors.NotStacked(branch=find('branch'))
2799
elif err.error_verb == 'PermissionDenied':
2801
if len(err.error_args) >= 2:
2802
extra = err.error_args[1]
2805
raise errors.PermissionDenied(path, extra=extra)
2806
elif err.error_verb == 'ReadError':
2808
raise errors.ReadError(path)
2809
elif err.error_verb == 'NoSuchFile':
2811
raise errors.NoSuchFile(path)
2812
elif err.error_verb == 'FileExists':
2813
raise errors.FileExists(err.error_args[0])
2814
elif err.error_verb == 'DirectoryNotEmpty':
2815
raise errors.DirectoryNotEmpty(err.error_args[0])
2816
elif err.error_verb == 'ShortReadvError':
2817
args = err.error_args
2818
raise errors.ShortReadvError(
2819
args[0], int(args[1]), int(args[2]), int(args[3]))
2820
elif err.error_verb in ('UnicodeEncodeError', 'UnicodeDecodeError'):
2821
encoding = str(err.error_args[0]) # encoding must always be a string
2822
val = err.error_args[1]
2823
start = int(err.error_args[2])
2824
end = int(err.error_args[3])
2825
reason = str(err.error_args[4]) # reason must always be a string
2826
if val.startswith('u:'):
2827
val = val[2:].decode('utf-8')
2828
elif val.startswith('s:'):
2829
val = val[2:].decode('base64')
2830
if err.error_verb == 'UnicodeDecodeError':
2831
raise UnicodeDecodeError(encoding, val, start, end, reason)
2832
elif err.error_verb == 'UnicodeEncodeError':
2833
raise UnicodeEncodeError(encoding, val, start, end, reason)
2834
elif err.error_verb == 'ReadOnlyError':
2835
raise errors.TransportNotPossible('readonly transport')
2836
raise errors.UnknownErrorFromSmartServer(err)
added
removed
bzrlib/remote.py
