1
# Copyright (C) 2006-2010 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
30
repository as _mod_repository,
32
revision as _mod_revision,
36
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
37
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
38
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
39
from bzrlib.errors import (
43
from bzrlib.lockable_files import LockableFiles
44
from bzrlib.smart import client, vfs, repository as smart_repo
45
from bzrlib.revision import ensure_null, NULL_REVISION
46
from bzrlib.repository import RepositoryWriteLockResult
47
from bzrlib.trace import mutter, note, warning
50
class _RpcHelper(object):
51
"""Mixin class that helps with issuing RPCs."""
53
def _call(self, method, *args, **err_context):
55
return self._client.call(method, *args)
56
except errors.ErrorFromSmartServer, err:
57
self._translate_error(err, **err_context)
59
def _call_expecting_body(self, method, *args, **err_context):
61
return self._client.call_expecting_body(method, *args)
62
except errors.ErrorFromSmartServer, err:
63
self._translate_error(err, **err_context)
65
def _call_with_body_bytes(self, method, args, body_bytes, **err_context):
67
return self._client.call_with_body_bytes(method, args, body_bytes)
68
except errors.ErrorFromSmartServer, err:
69
self._translate_error(err, **err_context)
71
def _call_with_body_bytes_expecting_body(self, method, args, body_bytes,
74
return self._client.call_with_body_bytes_expecting_body(
75
method, args, body_bytes)
76
except errors.ErrorFromSmartServer, err:
77
self._translate_error(err, **err_context)
80
def response_tuple_to_repo_format(response):
81
"""Convert a response tuple describing a repository format to a format."""
82
format = RemoteRepositoryFormat()
83
format._rich_root_data = (response[0] == 'yes')
84
format._supports_tree_reference = (response[1] == 'yes')
85
format._supports_external_lookups = (response[2] == 'yes')
86
format._network_name = response[3]
90
# Note: RemoteBzrDirFormat is in bzrdir.py
92
class RemoteBzrDir(BzrDir, _RpcHelper):
93
"""Control directory on a remote server, accessed via bzr:// or similar."""
95
def __init__(self, transport, format, _client=None, _force_probe=False):
96
"""Construct a RemoteBzrDir.
98
:param _client: Private parameter for testing. Disables probing and the
101
BzrDir.__init__(self, transport, format)
102
# this object holds a delegated bzrdir that uses file-level operations
103
# to talk to the other side
104
self._real_bzrdir = None
105
self._has_working_tree = None
106
# 1-shot cache for the call pattern 'create_branch; open_branch' - see
107
# create_branch for details.
108
self._next_open_branch_result = None
111
medium = transport.get_smart_medium()
112
self._client = client._SmartClient(medium)
114
self._client = _client
121
return '%s(%r)' % (self.__class__.__name__, self._client)
123
def _probe_bzrdir(self):
124
medium = self._client._medium
125
path = self._path_for_remote_call(self._client)
126
if medium._is_remote_before((2, 1)):
130
self._rpc_open_2_1(path)
132
except errors.UnknownSmartMethod:
133
medium._remember_remote_is_before((2, 1))
136
def _rpc_open_2_1(self, path):
137
response = self._call('BzrDir.open_2.1', path)
138
if response == ('no',):
139
raise errors.NotBranchError(path=self.root_transport.base)
140
elif response[0] == 'yes':
141
if response[1] == 'yes':
142
self._has_working_tree = True
143
elif response[1] == 'no':
144
self._has_working_tree = False
146
raise errors.UnexpectedSmartServerResponse(response)
148
raise errors.UnexpectedSmartServerResponse(response)
150
def _rpc_open(self, path):
151
response = self._call('BzrDir.open', path)
152
if response not in [('yes',), ('no',)]:
153
raise errors.UnexpectedSmartServerResponse(response)
154
if response == ('no',):
155
raise errors.NotBranchError(path=self.root_transport.base)
157
def _ensure_real(self):
158
"""Ensure that there is a _real_bzrdir set.
160
Used before calls to self._real_bzrdir.
162
if not self._real_bzrdir:
163
if 'hpssvfs' in debug.debug_flags:
165
warning('VFS BzrDir access triggered\n%s',
166
''.join(traceback.format_stack()))
167
self._real_bzrdir = BzrDir.open_from_transport(
168
self.root_transport, _server_formats=False)
169
self._format._network_name = \
170
self._real_bzrdir._format.network_name()
172
def _translate_error(self, err, **context):
173
_translate_error(err, bzrdir=self, **context)
175
def break_lock(self):
176
# Prevent aliasing problems in the next_open_branch_result cache.
177
# See create_branch for rationale.
178
self._next_open_branch_result = None
179
return BzrDir.break_lock(self)
181
def _vfs_cloning_metadir(self, require_stacking=False):
183
return self._real_bzrdir.cloning_metadir(
184
require_stacking=require_stacking)
186
def cloning_metadir(self, require_stacking=False):
187
medium = self._client._medium
188
if medium._is_remote_before((1, 13)):
189
return self._vfs_cloning_metadir(require_stacking=require_stacking)
190
verb = 'BzrDir.cloning_metadir'
195
path = self._path_for_remote_call(self._client)
197
response = self._call(verb, path, stacking)
198
except errors.UnknownSmartMethod:
199
medium._remember_remote_is_before((1, 13))
200
return self._vfs_cloning_metadir(require_stacking=require_stacking)
201
except errors.UnknownErrorFromSmartServer, err:
202
if err.error_tuple != ('BranchReference',):
204
# We need to resolve the branch reference to determine the
205
# cloning_metadir. This causes unnecessary RPCs to open the
206
# referenced branch (and bzrdir, etc) but only when the caller
207
# didn't already resolve the branch reference.
208
referenced_branch = self.open_branch()
209
return referenced_branch.bzrdir.cloning_metadir()
210
if len(response) != 3:
211
raise errors.UnexpectedSmartServerResponse(response)
212
control_name, repo_name, branch_info = response
213
if len(branch_info) != 2:
214
raise errors.UnexpectedSmartServerResponse(response)
215
branch_ref, branch_name = branch_info
216
format = bzrdir.network_format_registry.get(control_name)
218
format.repository_format = repository.network_format_registry.get(
220
if branch_ref == 'ref':
221
# XXX: we need possible_transports here to avoid reopening the
222
# connection to the referenced location
223
ref_bzrdir = BzrDir.open(branch_name)
224
branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
225
format.set_branch_format(branch_format)
226
elif branch_ref == 'branch':
228
format.set_branch_format(
229
branch.network_format_registry.get(branch_name))
231
raise errors.UnexpectedSmartServerResponse(response)
234
def create_repository(self, shared=False):
235
# as per meta1 formats - just delegate to the format object which may
237
result = self._format.repository_format.initialize(self, shared)
238
if not isinstance(result, RemoteRepository):
239
return self.open_repository()
243
def destroy_repository(self):
244
"""See BzrDir.destroy_repository"""
246
self._real_bzrdir.destroy_repository()
248
def create_branch(self, name=None):
249
# as per meta1 formats - just delegate to the format object which may
251
real_branch = self._format.get_branch_format().initialize(self,
253
if not isinstance(real_branch, RemoteBranch):
254
result = RemoteBranch(self, self.find_repository(), real_branch,
258
# BzrDir.clone_on_transport() uses the result of create_branch but does
259
# not return it to its callers; we save approximately 8% of our round
260
# trips by handing the branch we created back to the first caller to
261
# open_branch rather than probing anew. Long term we need a API in
262
# bzrdir that doesn't discard result objects (like result_branch).
264
self._next_open_branch_result = result
267
def destroy_branch(self, name=None):
268
"""See BzrDir.destroy_branch"""
270
self._real_bzrdir.destroy_branch(name=name)
271
self._next_open_branch_result = None
273
def create_workingtree(self, revision_id=None, from_branch=None):
274
raise errors.NotLocalUrl(self.transport.base)
276
def find_branch_format(self):
277
"""Find the branch 'format' for this bzrdir.
279
This might be a synthetic object for e.g. RemoteBranch and SVN.
281
b = self.open_branch()
284
def get_branch_reference(self):
285
"""See BzrDir.get_branch_reference()."""
286
response = self._get_branch_reference()
287
if response[0] == 'ref':
292
def _get_branch_reference(self):
293
path = self._path_for_remote_call(self._client)
294
medium = self._client._medium
296
('BzrDir.open_branchV3', (2, 1)),
297
('BzrDir.open_branchV2', (1, 13)),
298
('BzrDir.open_branch', None),
300
for verb, required_version in candidate_calls:
301
if required_version and medium._is_remote_before(required_version):
304
response = self._call(verb, path)
305
except errors.UnknownSmartMethod:
306
if required_version is None:
308
medium._remember_remote_is_before(required_version)
311
if verb == 'BzrDir.open_branch':
312
if response[0] != 'ok':
313
raise errors.UnexpectedSmartServerResponse(response)
314
if response[1] != '':
315
return ('ref', response[1])
317
return ('branch', '')
318
if response[0] not in ('ref', 'branch'):
319
raise errors.UnexpectedSmartServerResponse(response)
322
def _get_tree_branch(self):
323
"""See BzrDir._get_tree_branch()."""
324
return None, self.open_branch()
326
def open_branch(self, name=None, unsupported=False,
327
ignore_fallbacks=False):
329
raise NotImplementedError('unsupported flag support not implemented yet.')
330
if self._next_open_branch_result is not None:
331
# See create_branch for details.
332
result = self._next_open_branch_result
333
self._next_open_branch_result = None
335
response = self._get_branch_reference()
336
if response[0] == 'ref':
337
# a branch reference, use the existing BranchReference logic.
338
format = BranchReferenceFormat()
339
return format.open(self, name=name, _found=True,
340
location=response[1], ignore_fallbacks=ignore_fallbacks)
341
branch_format_name = response[1]
342
if not branch_format_name:
343
branch_format_name = None
344
format = RemoteBranchFormat(network_name=branch_format_name)
345
return RemoteBranch(self, self.find_repository(), format=format,
346
setup_stacking=not ignore_fallbacks, name=name)
348
def _open_repo_v1(self, path):
349
verb = 'BzrDir.find_repository'
350
response = self._call(verb, path)
351
if response[0] != 'ok':
352
raise errors.UnexpectedSmartServerResponse(response)
353
# servers that only support the v1 method don't support external
356
repo = self._real_bzrdir.open_repository()
357
response = response + ('no', repo._format.network_name())
358
return response, repo
360
def _open_repo_v2(self, path):
361
verb = 'BzrDir.find_repositoryV2'
362
response = self._call(verb, path)
363
if response[0] != 'ok':
364
raise errors.UnexpectedSmartServerResponse(response)
366
repo = self._real_bzrdir.open_repository()
367
response = response + (repo._format.network_name(),)
368
return response, repo
370
def _open_repo_v3(self, path):
371
verb = 'BzrDir.find_repositoryV3'
372
medium = self._client._medium
373
if medium._is_remote_before((1, 13)):
374
raise errors.UnknownSmartMethod(verb)
376
response = self._call(verb, path)
377
except errors.UnknownSmartMethod:
378
medium._remember_remote_is_before((1, 13))
380
if response[0] != 'ok':
381
raise errors.UnexpectedSmartServerResponse(response)
382
return response, None
384
def open_repository(self):
385
path = self._path_for_remote_call(self._client)
387
for probe in [self._open_repo_v3, self._open_repo_v2,
390
response, real_repo = probe(path)
392
except errors.UnknownSmartMethod:
395
raise errors.UnknownSmartMethod('BzrDir.find_repository{3,2,}')
396
if response[0] != 'ok':
397
raise errors.UnexpectedSmartServerResponse(response)
398
if len(response) != 6:
399
raise SmartProtocolError('incorrect response length %s' % (response,))
400
if response[1] == '':
401
# repo is at this dir.
402
format = response_tuple_to_repo_format(response[2:])
403
# Used to support creating a real format instance when needed.
404
format._creating_bzrdir = self
405
remote_repo = RemoteRepository(self, format)
406
format._creating_repo = remote_repo
407
if real_repo is not None:
408
remote_repo._set_real_repository(real_repo)
411
raise errors.NoRepositoryPresent(self)
413
def has_workingtree(self):
414
if self._has_working_tree is None:
416
self._has_working_tree = self._real_bzrdir.has_workingtree()
417
return self._has_working_tree
419
def open_workingtree(self, recommend_upgrade=True):
420
if self.has_workingtree():
421
raise errors.NotLocalUrl(self.root_transport)
423
raise errors.NoWorkingTree(self.root_transport.base)
425
def _path_for_remote_call(self, client):
426
"""Return the path to be used for this bzrdir in a remote call."""
427
return client.remote_path_from_transport(self.root_transport)
429
def get_branch_transport(self, branch_format, name=None):
431
return self._real_bzrdir.get_branch_transport(branch_format, name=name)
433
def get_repository_transport(self, repository_format):
435
return self._real_bzrdir.get_repository_transport(repository_format)
437
def get_workingtree_transport(self, workingtree_format):
439
return self._real_bzrdir.get_workingtree_transport(workingtree_format)
441
def can_convert_format(self):
442
"""Upgrading of remote bzrdirs is not supported yet."""
445
def needs_format_conversion(self, format=None):
446
"""Upgrading of remote bzrdirs is not supported yet."""
448
symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
449
% 'needs_format_conversion(format=None)')
452
def clone(self, url, revision_id=None, force_new_repo=False,
453
preserve_stacking=False):
455
return self._real_bzrdir.clone(url, revision_id=revision_id,
456
force_new_repo=force_new_repo, preserve_stacking=preserve_stacking)
458
def _get_config(self):
459
return RemoteBzrDirConfig(self)
462
class RemoteRepositoryFormat(repository.RepositoryFormat):
463
"""Format for repositories accessed over a _SmartClient.
465
Instances of this repository are represented by RemoteRepository
468
The RemoteRepositoryFormat is parameterized during construction
469
to reflect the capabilities of the real, remote format. Specifically
470
the attributes rich_root_data and supports_tree_reference are set
471
on a per instance basis, and are not set (and should not be) at
474
:ivar _custom_format: If set, a specific concrete repository format that
475
will be used when initializing a repository with this
476
RemoteRepositoryFormat.
477
:ivar _creating_repo: If set, the repository object that this
478
RemoteRepositoryFormat was created for: it can be called into
479
to obtain data like the network name.
482
_matchingbzrdir = RemoteBzrDirFormat()
485
repository.RepositoryFormat.__init__(self)
486
self._custom_format = None
487
self._network_name = None
488
self._creating_bzrdir = None
489
self._supports_chks = None
490
self._supports_external_lookups = None
491
self._supports_tree_reference = None
492
self._rich_root_data = None
495
return "%s(_network_name=%r)" % (self.__class__.__name__,
499
def fast_deltas(self):
501
return self._custom_format.fast_deltas
504
def rich_root_data(self):
505
if self._rich_root_data is None:
507
self._rich_root_data = self._custom_format.rich_root_data
508
return self._rich_root_data
511
def supports_chks(self):
512
if self._supports_chks is None:
514
self._supports_chks = self._custom_format.supports_chks
515
return self._supports_chks
518
def supports_external_lookups(self):
519
if self._supports_external_lookups is None:
521
self._supports_external_lookups = \
522
self._custom_format.supports_external_lookups
523
return self._supports_external_lookups
526
def supports_tree_reference(self):
527
if self._supports_tree_reference is None:
529
self._supports_tree_reference = \
530
self._custom_format.supports_tree_reference
531
return self._supports_tree_reference
533
def _vfs_initialize(self, a_bzrdir, shared):
534
"""Helper for common code in initialize."""
535
if self._custom_format:
536
# Custom format requested
537
result = self._custom_format.initialize(a_bzrdir, shared=shared)
538
elif self._creating_bzrdir is not None:
539
# Use the format that the repository we were created to back
541
prior_repo = self._creating_bzrdir.open_repository()
542
prior_repo._ensure_real()
543
result = prior_repo._real_repository._format.initialize(
544
a_bzrdir, shared=shared)
546
# assume that a_bzr is a RemoteBzrDir but the smart server didn't
547
# support remote initialization.
548
# We delegate to a real object at this point (as RemoteBzrDir
549
# delegate to the repository format which would lead to infinite
550
# recursion if we just called a_bzrdir.create_repository.
551
a_bzrdir._ensure_real()
552
result = a_bzrdir._real_bzrdir.create_repository(shared=shared)
553
if not isinstance(result, RemoteRepository):
554
return self.open(a_bzrdir)
558
def initialize(self, a_bzrdir, shared=False):
559
# Being asked to create on a non RemoteBzrDir:
560
if not isinstance(a_bzrdir, RemoteBzrDir):
561
return self._vfs_initialize(a_bzrdir, shared)
562
medium = a_bzrdir._client._medium
563
if medium._is_remote_before((1, 13)):
564
return self._vfs_initialize(a_bzrdir, shared)
565
# Creating on a remote bzr dir.
566
# 1) get the network name to use.
567
if self._custom_format:
568
network_name = self._custom_format.network_name()
569
elif self._network_name:
570
network_name = self._network_name
572
# Select the current bzrlib default and ask for that.
573
reference_bzrdir_format = bzrdir.format_registry.get('default')()
574
reference_format = reference_bzrdir_format.repository_format
575
network_name = reference_format.network_name()
576
# 2) try direct creation via RPC
577
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
578
verb = 'BzrDir.create_repository'
584
response = a_bzrdir._call(verb, path, network_name, shared_str)
585
except errors.UnknownSmartMethod:
586
# Fallback - use vfs methods
587
medium._remember_remote_is_before((1, 13))
588
return self._vfs_initialize(a_bzrdir, shared)
590
# Turn the response into a RemoteRepository object.
591
format = response_tuple_to_repo_format(response[1:])
592
# Used to support creating a real format instance when needed.
593
format._creating_bzrdir = a_bzrdir
594
remote_repo = RemoteRepository(a_bzrdir, format)
595
format._creating_repo = remote_repo
598
def open(self, a_bzrdir):
599
if not isinstance(a_bzrdir, RemoteBzrDir):
600
raise AssertionError('%r is not a RemoteBzrDir' % (a_bzrdir,))
601
return a_bzrdir.open_repository()
603
def _ensure_real(self):
604
if self._custom_format is None:
605
self._custom_format = repository.network_format_registry.get(
609
def _fetch_order(self):
611
return self._custom_format._fetch_order
614
def _fetch_uses_deltas(self):
616
return self._custom_format._fetch_uses_deltas
619
def _fetch_reconcile(self):
621
return self._custom_format._fetch_reconcile
623
def get_format_description(self):
625
return 'Remote: ' + self._custom_format.get_format_description()
627
def __eq__(self, other):
628
return self.__class__ is other.__class__
630
def network_name(self):
631
if self._network_name:
632
return self._network_name
633
self._creating_repo._ensure_real()
634
return self._creating_repo._real_repository._format.network_name()
637
def pack_compresses(self):
639
return self._custom_format.pack_compresses
642
def _serializer(self):
644
return self._custom_format._serializer
647
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
648
bzrdir.ControlComponent):
649
"""Repository accessed over rpc.
651
For the moment most operations are performed using local transport-backed
655
def __init__(self, remote_bzrdir, format, real_repository=None, _client=None):
656
"""Create a RemoteRepository instance.
658
:param remote_bzrdir: The bzrdir hosting this repository.
659
:param format: The RemoteFormat object to use.
660
:param real_repository: If not None, a local implementation of the
661
repository logic for the repository, usually accessing the data
663
:param _client: Private testing parameter - override the smart client
664
to be used by the repository.
667
self._real_repository = real_repository
669
self._real_repository = None
670
self.bzrdir = remote_bzrdir
672
self._client = remote_bzrdir._client
674
self._client = _client
675
self._format = format
676
self._lock_mode = None
677
self._lock_token = None
679
self._leave_lock = False
680
# Cache of revision parents; misses are cached during read locks, and
681
# write locks when no _real_repository has been set.
682
self._unstacked_provider = graph.CachingParentsProvider(
683
get_parent_map=self._get_parent_map_rpc)
684
self._unstacked_provider.disable_cache()
686
# These depend on the actual remote format, so force them off for
687
# maximum compatibility. XXX: In future these should depend on the
688
# remote repository instance, but this is irrelevant until we perform
689
# reconcile via an RPC call.
690
self._reconcile_does_inventory_gc = False
691
self._reconcile_fixes_text_parents = False
692
self._reconcile_backsup_inventory = False
693
self.base = self.bzrdir.transport.base
694
# Additional places to query for data.
695
self._fallback_repositories = []
698
def user_transport(self):
699
return self.bzrdir.user_transport
702
def control_transport(self):
703
# XXX: Normally you shouldn't directly get at the remote repository
704
# transport, but I'm not sure it's worth making this method
705
# optional -- mbp 2010-04-21
706
return self.bzrdir.get_repository_transport(None)
709
return "%s(%s)" % (self.__class__.__name__, self.base)
713
def abort_write_group(self, suppress_errors=False):
714
"""Complete a write group on the decorated repository.
716
Smart methods perform operations in a single step so this API
717
is not really applicable except as a compatibility thunk
718
for older plugins that don't use e.g. the CommitBuilder
721
:param suppress_errors: see Repository.abort_write_group.
724
return self._real_repository.abort_write_group(
725
suppress_errors=suppress_errors)
729
"""Decorate the real repository for now.
731
In the long term a full blown network facility is needed to avoid
732
creating a real repository object locally.
735
return self._real_repository.chk_bytes
737
def commit_write_group(self):
738
"""Complete a write group on the decorated repository.
740
Smart methods perform operations in a single step so this API
741
is not really applicable except as a compatibility thunk
742
for older plugins that don't use e.g. the CommitBuilder
746
return self._real_repository.commit_write_group()
748
def resume_write_group(self, tokens):
750
return self._real_repository.resume_write_group(tokens)
752
def suspend_write_group(self):
754
return self._real_repository.suspend_write_group()
756
def get_missing_parent_inventories(self, check_for_missing_texts=True):
758
return self._real_repository.get_missing_parent_inventories(
759
check_for_missing_texts=check_for_missing_texts)
761
def _get_rev_id_for_revno_vfs(self, revno, known_pair):
763
return self._real_repository.get_rev_id_for_revno(
766
def get_rev_id_for_revno(self, revno, known_pair):
767
"""See Repository.get_rev_id_for_revno."""
768
path = self.bzrdir._path_for_remote_call(self._client)
770
if self._client._medium._is_remote_before((1, 17)):
771
return self._get_rev_id_for_revno_vfs(revno, known_pair)
772
response = self._call(
773
'Repository.get_rev_id_for_revno', path, revno, known_pair)
774
except errors.UnknownSmartMethod:
775
self._client._medium._remember_remote_is_before((1, 17))
776
return self._get_rev_id_for_revno_vfs(revno, known_pair)
777
if response[0] == 'ok':
778
return True, response[1]
779
elif response[0] == 'history-incomplete':
780
known_pair = response[1:3]
781
for fallback in self._fallback_repositories:
782
found, result = fallback.get_rev_id_for_revno(revno, known_pair)
787
# Not found in any fallbacks
788
return False, known_pair
790
raise errors.UnexpectedSmartServerResponse(response)
792
def _ensure_real(self):
793
"""Ensure that there is a _real_repository set.
795
Used before calls to self._real_repository.
797
Note that _ensure_real causes many roundtrips to the server which are
798
not desirable, and prevents the use of smart one-roundtrip RPC's to
799
perform complex operations (such as accessing parent data, streaming
800
revisions etc). Adding calls to _ensure_real should only be done when
801
bringing up new functionality, adding fallbacks for smart methods that
802
require a fallback path, and never to replace an existing smart method
803
invocation. If in doubt chat to the bzr network team.
805
if self._real_repository is None:
806
if 'hpssvfs' in debug.debug_flags:
808
warning('VFS Repository access triggered\n%s',
809
''.join(traceback.format_stack()))
810
self._unstacked_provider.missing_keys.clear()
811
self.bzrdir._ensure_real()
812
self._set_real_repository(
813
self.bzrdir._real_bzrdir.open_repository())
815
def _translate_error(self, err, **context):
816
self.bzrdir._translate_error(err, repository=self, **context)
818
def find_text_key_references(self):
819
"""Find the text key references within the repository.
821
:return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
822
revision_ids. Each altered file-ids has the exact revision_ids that
823
altered it listed explicitly.
824
:return: A dictionary mapping text keys ((fileid, revision_id) tuples)
825
to whether they were referred to by the inventory of the
826
revision_id that they contain. The inventory texts from all present
827
revision ids are assessed to generate this report.
830
return self._real_repository.find_text_key_references()
832
def _generate_text_key_index(self):
833
"""Generate a new text key index for the repository.
835
This is an expensive function that will take considerable time to run.
837
:return: A dict mapping (file_id, revision_id) tuples to a list of
838
parents, also (file_id, revision_id) tuples.
841
return self._real_repository._generate_text_key_index()
843
def _get_revision_graph(self, revision_id):
844
"""Private method for using with old (< 1.2) servers to fallback."""
845
if revision_id is None:
847
elif revision.is_null(revision_id):
850
path = self.bzrdir._path_for_remote_call(self._client)
851
response = self._call_expecting_body(
852
'Repository.get_revision_graph', path, revision_id)
853
response_tuple, response_handler = response
854
if response_tuple[0] != 'ok':
855
raise errors.UnexpectedSmartServerResponse(response_tuple)
856
coded = response_handler.read_body_bytes()
858
# no revisions in this repository!
860
lines = coded.split('\n')
863
d = tuple(line.split())
864
revision_graph[d[0]] = d[1:]
866
return revision_graph
869
"""See Repository._get_sink()."""
870
return RemoteStreamSink(self)
872
def _get_source(self, to_format):
873
"""Return a source for streaming from this repository."""
874
return RemoteStreamSource(self, to_format)
877
def has_revision(self, revision_id):
878
"""True if this repository has a copy of the revision."""
879
# Copy of bzrlib.repository.Repository.has_revision
880
return revision_id in self.has_revisions((revision_id,))
883
def has_revisions(self, revision_ids):
884
"""Probe to find out the presence of multiple revisions.
886
:param revision_ids: An iterable of revision_ids.
887
:return: A set of the revision_ids that were present.
889
# Copy of bzrlib.repository.Repository.has_revisions
890
parent_map = self.get_parent_map(revision_ids)
891
result = set(parent_map)
892
if _mod_revision.NULL_REVISION in revision_ids:
893
result.add(_mod_revision.NULL_REVISION)
896
def _has_same_fallbacks(self, other_repo):
897
"""Returns true if the repositories have the same fallbacks."""
898
# XXX: copied from Repository; it should be unified into a base class
899
# <https://bugs.edge.launchpad.net/bzr/+bug/401622>
900
my_fb = self._fallback_repositories
901
other_fb = other_repo._fallback_repositories
902
if len(my_fb) != len(other_fb):
904
for f, g in zip(my_fb, other_fb):
905
if not f.has_same_location(g):
909
def has_same_location(self, other):
910
# TODO: Move to RepositoryBase and unify with the regular Repository
911
# one; unfortunately the tests rely on slightly different behaviour at
912
# present -- mbp 20090710
913
return (self.__class__ is other.__class__ and
914
self.bzrdir.transport.base == other.bzrdir.transport.base)
916
def get_graph(self, other_repository=None):
917
"""Return the graph for this repository format"""
918
parents_provider = self._make_parents_provider(other_repository)
919
return graph.Graph(parents_provider)
922
def get_known_graph_ancestry(self, revision_ids):
923
"""Return the known graph for a set of revision ids and their ancestors.
925
st = static_tuple.StaticTuple
926
revision_keys = [st(r_id).intern() for r_id in revision_ids]
927
known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
928
return graph.GraphThunkIdsToKeys(known_graph)
930
def gather_stats(self, revid=None, committers=None):
931
"""See Repository.gather_stats()."""
932
path = self.bzrdir._path_for_remote_call(self._client)
933
# revid can be None to indicate no revisions, not just NULL_REVISION
934
if revid is None or revision.is_null(revid):
938
if committers is None or not committers:
939
fmt_committers = 'no'
941
fmt_committers = 'yes'
942
response_tuple, response_handler = self._call_expecting_body(
943
'Repository.gather_stats', path, fmt_revid, fmt_committers)
944
if response_tuple[0] != 'ok':
945
raise errors.UnexpectedSmartServerResponse(response_tuple)
947
body = response_handler.read_body_bytes()
949
for line in body.split('\n'):
952
key, val_text = line.split(':')
953
if key in ('revisions', 'size', 'committers'):
954
result[key] = int(val_text)
955
elif key in ('firstrev', 'latestrev'):
956
values = val_text.split(' ')[1:]
957
result[key] = (float(values[0]), long(values[1]))
961
def find_branches(self, using=False):
962
"""See Repository.find_branches()."""
963
# should be an API call to the server.
965
return self._real_repository.find_branches(using=using)
967
def get_physical_lock_status(self):
968
"""See Repository.get_physical_lock_status()."""
969
# should be an API call to the server.
971
return self._real_repository.get_physical_lock_status()
973
def is_in_write_group(self):
974
"""Return True if there is an open write group.
976
write groups are only applicable locally for the smart server..
978
if self._real_repository:
979
return self._real_repository.is_in_write_group()
982
return self._lock_count >= 1
985
"""See Repository.is_shared()."""
986
path = self.bzrdir._path_for_remote_call(self._client)
987
response = self._call('Repository.is_shared', path)
988
if response[0] not in ('yes', 'no'):
989
raise SmartProtocolError('unexpected response code %s' % (response,))
990
return response[0] == 'yes'
992
def is_write_locked(self):
993
return self._lock_mode == 'w'
995
def _warn_if_deprecated(self, branch=None):
996
# If we have a real repository, the check will be done there, if we
997
# don't the check will be done remotely.
1000
def lock_read(self):
1001
"""Lock the repository for read operations.
1003
:return: A bzrlib.lock.LogicalLockResult.
1005
# wrong eventually - want a local lock cache context
1006
if not self._lock_mode:
1007
self._note_lock('r')
1008
self._lock_mode = 'r'
1009
self._lock_count = 1
1010
self._unstacked_provider.enable_cache(cache_misses=True)
1011
if self._real_repository is not None:
1012
self._real_repository.lock_read()
1013
for repo in self._fallback_repositories:
1016
self._lock_count += 1
1017
return lock.LogicalLockResult(self.unlock)
1019
def _remote_lock_write(self, token):
1020
path = self.bzrdir._path_for_remote_call(self._client)
1023
err_context = {'token': token}
1024
response = self._call('Repository.lock_write', path, token,
1026
if response[0] == 'ok':
1027
ok, token = response
1030
raise errors.UnexpectedSmartServerResponse(response)
1032
def lock_write(self, token=None, _skip_rpc=False):
1033
if not self._lock_mode:
1034
self._note_lock('w')
1036
if self._lock_token is not None:
1037
if token != self._lock_token:
1038
raise errors.TokenMismatch(token, self._lock_token)
1039
self._lock_token = token
1041
self._lock_token = self._remote_lock_write(token)
1042
# if self._lock_token is None, then this is something like packs or
1043
# svn where we don't get to lock the repo, or a weave style repository
1044
# where we cannot lock it over the wire and attempts to do so will
1046
if self._real_repository is not None:
1047
self._real_repository.lock_write(token=self._lock_token)
1048
if token is not None:
1049
self._leave_lock = True
1051
self._leave_lock = False
1052
self._lock_mode = 'w'
1053
self._lock_count = 1
1054
cache_misses = self._real_repository is None
1055
self._unstacked_provider.enable_cache(cache_misses=cache_misses)
1056
for repo in self._fallback_repositories:
1057
# Writes don't affect fallback repos
1059
elif self._lock_mode == 'r':
1060
raise errors.ReadOnlyError(self)
1062
self._lock_count += 1
1063
return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
1065
def leave_lock_in_place(self):
1066
if not self._lock_token:
1067
raise NotImplementedError(self.leave_lock_in_place)
1068
self._leave_lock = True
1070
def dont_leave_lock_in_place(self):
1071
if not self._lock_token:
1072
raise NotImplementedError(self.dont_leave_lock_in_place)
1073
self._leave_lock = False
1075
def _set_real_repository(self, repository):
1076
"""Set the _real_repository for this repository.
1078
:param repository: The repository to fallback to for non-hpss
1079
implemented operations.
1081
if self._real_repository is not None:
1082
# Replacing an already set real repository.
1083
# We cannot do this [currently] if the repository is locked -
1084
# synchronised state might be lost.
1085
if self.is_locked():
1086
raise AssertionError('_real_repository is already set')
1087
if isinstance(repository, RemoteRepository):
1088
raise AssertionError()
1089
self._real_repository = repository
1090
# three code paths happen here:
1091
# 1) old servers, RemoteBranch.open() calls _ensure_real before setting
1092
# up stacking. In this case self._fallback_repositories is [], and the
1093
# real repo is already setup. Preserve the real repo and
1094
# RemoteRepository.add_fallback_repository will avoid adding
1096
# 2) new servers, RemoteBranch.open() sets up stacking, and when
1097
# ensure_real is triggered from a branch, the real repository to
1098
# set already has a matching list with separate instances, but
1099
# as they are also RemoteRepositories we don't worry about making the
1100
# lists be identical.
1101
# 3) new servers, RemoteRepository.ensure_real is triggered before
1102
# RemoteBranch.ensure real, in this case we get a repo with no fallbacks
1103
# and need to populate it.
1104
if (self._fallback_repositories and
1105
len(self._real_repository._fallback_repositories) !=
1106
len(self._fallback_repositories)):
1107
if len(self._real_repository._fallback_repositories):
1108
raise AssertionError(
1109
"cannot cleanly remove existing _fallback_repositories")
1110
for fb in self._fallback_repositories:
1111
self._real_repository.add_fallback_repository(fb)
1112
if self._lock_mode == 'w':
1113
# if we are already locked, the real repository must be able to
1114
# acquire the lock with our token.
1115
self._real_repository.lock_write(self._lock_token)
1116
elif self._lock_mode == 'r':
1117
self._real_repository.lock_read()
1119
def start_write_group(self):
1120
"""Start a write group on the decorated repository.
1122
Smart methods perform operations in a single step so this API
1123
is not really applicable except as a compatibility thunk
1124
for older plugins that don't use e.g. the CommitBuilder
1128
return self._real_repository.start_write_group()
1130
def _unlock(self, token):
1131
path = self.bzrdir._path_for_remote_call(self._client)
1133
# with no token the remote repository is not persistently locked.
1135
err_context = {'token': token}
1136
response = self._call('Repository.unlock', path, token,
1138
if response == ('ok',):
1141
raise errors.UnexpectedSmartServerResponse(response)
1143
@only_raises(errors.LockNotHeld, errors.LockBroken)
1145
if not self._lock_count:
1146
return lock.cant_unlock_not_held(self)
1147
self._lock_count -= 1
1148
if self._lock_count > 0:
1150
self._unstacked_provider.disable_cache()
1151
old_mode = self._lock_mode
1152
self._lock_mode = None
1154
# The real repository is responsible at present for raising an
1155
# exception if it's in an unfinished write group. However, it
1156
# normally will *not* actually remove the lock from disk - that's
1157
# done by the server on receiving the Repository.unlock call.
1158
# This is just to let the _real_repository stay up to date.
1159
if self._real_repository is not None:
1160
self._real_repository.unlock()
1162
# The rpc-level lock should be released even if there was a
1163
# problem releasing the vfs-based lock.
1165
# Only write-locked repositories need to make a remote method
1166
# call to perform the unlock.
1167
old_token = self._lock_token
1168
self._lock_token = None
1169
if not self._leave_lock:
1170
self._unlock(old_token)
1171
# Fallbacks are always 'lock_read()' so we don't pay attention to
1173
for repo in self._fallback_repositories:
1176
def break_lock(self):
1177
# should hand off to the network
1179
return self._real_repository.break_lock()
1181
def _get_tarball(self, compression):
1182
"""Return a TemporaryFile containing a repository tarball.
1184
Returns None if the server does not support sending tarballs.
1187
path = self.bzrdir._path_for_remote_call(self._client)
1189
response, protocol = self._call_expecting_body(
1190
'Repository.tarball', path, compression)
1191
except errors.UnknownSmartMethod:
1192
protocol.cancel_read_body()
1194
if response[0] == 'ok':
1195
# Extract the tarball and return it
1196
t = tempfile.NamedTemporaryFile()
1197
# TODO: rpc layer should read directly into it...
1198
t.write(protocol.read_body_bytes())
1201
raise errors.UnexpectedSmartServerResponse(response)
1203
def sprout(self, to_bzrdir, revision_id=None):
1204
# TODO: Option to control what format is created?
1206
dest_repo = self._real_repository._format.initialize(to_bzrdir,
1208
dest_repo.fetch(self, revision_id=revision_id)
1211
### These methods are just thin shims to the VFS object for now.
1213
def revision_tree(self, revision_id):
1215
return self._real_repository.revision_tree(revision_id)
1217
def get_serializer_format(self):
1219
return self._real_repository.get_serializer_format()
1221
def get_commit_builder(self, branch, parents, config, timestamp=None,
1222
timezone=None, committer=None, revprops=None,
1224
# FIXME: It ought to be possible to call this without immediately
1225
# triggering _ensure_real. For now it's the easiest thing to do.
1227
real_repo = self._real_repository
1228
builder = real_repo.get_commit_builder(branch, parents,
1229
config, timestamp=timestamp, timezone=timezone,
1230
committer=committer, revprops=revprops, revision_id=revision_id)
1233
def add_fallback_repository(self, repository):
1234
"""Add a repository to use for looking up data not held locally.
1236
:param repository: A repository.
1238
if not self._format.supports_external_lookups:
1239
raise errors.UnstackableRepositoryFormat(
1240
self._format.network_name(), self.base)
1241
# We need to accumulate additional repositories here, to pass them in
1244
if self.is_locked():
1245
# We will call fallback.unlock() when we transition to the unlocked
1246
# state, so always add a lock here. If a caller passes us a locked
1247
# repository, they are responsible for unlocking it later.
1248
repository.lock_read()
1249
self._check_fallback_repository(repository)
1250
self._fallback_repositories.append(repository)
1251
# If self._real_repository was parameterised already (e.g. because a
1252
# _real_branch had its get_stacked_on_url method called), then the
1253
# repository to be added may already be in the _real_repositories list.
1254
if self._real_repository is not None:
1255
fallback_locations = [repo.user_url for repo in
1256
self._real_repository._fallback_repositories]
1257
if repository.user_url not in fallback_locations:
1258
self._real_repository.add_fallback_repository(repository)
1260
def _check_fallback_repository(self, repository):
1261
"""Check that this repository can fallback to repository safely.
1263
Raise an error if not.
1265
:param repository: A repository to fallback to.
1267
return _mod_repository.InterRepository._assert_same_model(
1270
def add_inventory(self, revid, inv, parents):
1272
return self._real_repository.add_inventory(revid, inv, parents)
1274
def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1275
parents, basis_inv=None, propagate_caches=False):
1277
return self._real_repository.add_inventory_by_delta(basis_revision_id,
1278
delta, new_revision_id, parents, basis_inv=basis_inv,
1279
propagate_caches=propagate_caches)
1281
def add_revision(self, rev_id, rev, inv=None, config=None):
1283
return self._real_repository.add_revision(
1284
rev_id, rev, inv=inv, config=config)
1287
def get_inventory(self, revision_id):
1289
return self._real_repository.get_inventory(revision_id)
1291
def iter_inventories(self, revision_ids, ordering=None):
1293
return self._real_repository.iter_inventories(revision_ids, ordering)
1296
def get_revision(self, revision_id):
1298
return self._real_repository.get_revision(revision_id)
1300
def get_transaction(self):
1302
return self._real_repository.get_transaction()
1305
def clone(self, a_bzrdir, revision_id=None):
1307
return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
1309
def make_working_trees(self):
1310
"""See Repository.make_working_trees"""
1312
return self._real_repository.make_working_trees()
1314
def refresh_data(self):
1315
"""Re-read any data needed to to synchronise with disk.
1317
This method is intended to be called after another repository instance
1318
(such as one used by a smart server) has inserted data into the
1319
repository. It may not be called during a write group, but may be
1320
called at any other time.
1322
if self.is_in_write_group():
1323
raise errors.InternalBzrError(
1324
"May not refresh_data while in a write group.")
1325
if self._real_repository is not None:
1326
self._real_repository.refresh_data()
1328
def revision_ids_to_search_result(self, result_set):
1329
"""Convert a set of revision ids to a graph SearchResult."""
1330
result_parents = set()
1331
for parents in self.get_graph().get_parent_map(
1332
result_set).itervalues():
1333
result_parents.update(parents)
1334
included_keys = result_set.intersection(result_parents)
1335
start_keys = result_set.difference(included_keys)
1336
exclude_keys = result_parents.difference(result_set)
1337
result = graph.SearchResult(start_keys, exclude_keys,
1338
len(result_set), result_set)
1342
def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1343
"""Return the revision ids that other has that this does not.
1345
These are returned in topological order.
1347
revision_id: only return revision ids included by revision_id.
1349
return repository.InterRepository.get(
1350
other, self).search_missing_revision_ids(revision_id, find_ghosts)
1352
def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
1354
# No base implementation to use as RemoteRepository is not a subclass
1355
# of Repository; so this is a copy of Repository.fetch().
1356
if fetch_spec is not None and revision_id is not None:
1357
raise AssertionError(
1358
"fetch_spec and revision_id are mutually exclusive.")
1359
if self.is_in_write_group():
1360
raise errors.InternalBzrError(
1361
"May not fetch while in a write group.")
1362
# fast path same-url fetch operations
1363
if (self.has_same_location(source)
1364
and fetch_spec is None
1365
and self._has_same_fallbacks(source)):
1366
# check that last_revision is in 'from' and then return a
1368
if (revision_id is not None and
1369
not revision.is_null(revision_id)):
1370
self.get_revision(revision_id)
1372
# if there is no specific appropriate InterRepository, this will get
1373
# the InterRepository base class, which raises an
1374
# IncompatibleRepositories when asked to fetch.
1375
inter = repository.InterRepository.get(source, self)
1376
return inter.fetch(revision_id=revision_id, pb=pb,
1377
find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1379
def create_bundle(self, target, base, fileobj, format=None):
1381
self._real_repository.create_bundle(target, base, fileobj, format)
1384
def get_ancestry(self, revision_id, topo_sorted=True):
1386
return self._real_repository.get_ancestry(revision_id, topo_sorted)
1388
def fileids_altered_by_revision_ids(self, revision_ids):
1390
return self._real_repository.fileids_altered_by_revision_ids(revision_ids)
1392
def _get_versioned_file_checker(self, revisions, revision_versions_cache):
1394
return self._real_repository._get_versioned_file_checker(
1395
revisions, revision_versions_cache)
1397
def iter_files_bytes(self, desired_files):
1398
"""See Repository.iter_file_bytes.
1401
return self._real_repository.iter_files_bytes(desired_files)
1403
def get_parent_map(self, revision_ids):
1404
"""See bzrlib.Graph.get_parent_map()."""
1405
return self._make_parents_provider().get_parent_map(revision_ids)
1407
def _get_parent_map_rpc(self, keys):
1408
"""Helper for get_parent_map that performs the RPC."""
1409
medium = self._client._medium
1410
if medium._is_remote_before((1, 2)):
1411
# We already found out that the server can't understand
1412
# Repository.get_parent_map requests, so just fetch the whole
1415
# Note that this reads the whole graph, when only some keys are
1416
# wanted. On this old server there's no way (?) to get them all
1417
# in one go, and the user probably will have seen a warning about
1418
# the server being old anyhow.
1419
rg = self._get_revision_graph(None)
1420
# There is an API discrepancy between get_parent_map and
1421
# get_revision_graph. Specifically, a "key:()" pair in
1422
# get_revision_graph just means a node has no parents. For
1423
# "get_parent_map" it means the node is a ghost. So fix up the
1424
# graph to correct this.
1425
# https://bugs.launchpad.net/bzr/+bug/214894
1426
# There is one other "bug" which is that ghosts in
1427
# get_revision_graph() are not returned at all. But we won't worry
1428
# about that for now.
1429
for node_id, parent_ids in rg.iteritems():
1430
if parent_ids == ():
1431
rg[node_id] = (NULL_REVISION,)
1432
rg[NULL_REVISION] = ()
1437
raise ValueError('get_parent_map(None) is not valid')
1438
if NULL_REVISION in keys:
1439
keys.discard(NULL_REVISION)
1440
found_parents = {NULL_REVISION:()}
1442
return found_parents
1445
# TODO(Needs analysis): We could assume that the keys being requested
1446
# from get_parent_map are in a breadth first search, so typically they
1447
# will all be depth N from some common parent, and we don't have to
1448
# have the server iterate from the root parent, but rather from the
1449
# keys we're searching; and just tell the server the keyspace we
1450
# already have; but this may be more traffic again.
1452
# Transform self._parents_map into a search request recipe.
1453
# TODO: Manage this incrementally to avoid covering the same path
1454
# repeatedly. (The server will have to on each request, but the less
1455
# work done the better).
1457
# Negative caching notes:
1458
# new server sends missing when a request including the revid
1459
# 'include-missing:' is present in the request.
1460
# missing keys are serialised as missing:X, and we then call
1461
# provider.note_missing(X) for-all X
1462
parents_map = self._unstacked_provider.get_cached_map()
1463
if parents_map is None:
1464
# Repository is not locked, so there's no cache.
1466
# start_set is all the keys in the cache
1467
start_set = set(parents_map)
1468
# result set is all the references to keys in the cache
1469
result_parents = set()
1470
for parents in parents_map.itervalues():
1471
result_parents.update(parents)
1472
stop_keys = result_parents.difference(start_set)
1473
# We don't need to send ghosts back to the server as a position to
1475
stop_keys.difference_update(self._unstacked_provider.missing_keys)
1476
key_count = len(parents_map)
1477
if (NULL_REVISION in result_parents
1478
and NULL_REVISION in self._unstacked_provider.missing_keys):
1479
# If we pruned NULL_REVISION from the stop_keys because it's also
1480
# in our cache of "missing" keys we need to increment our key count
1481
# by 1, because the reconsitituted SearchResult on the server will
1482
# still consider NULL_REVISION to be an included key.
1484
included_keys = start_set.intersection(result_parents)
1485
start_set.difference_update(included_keys)
1486
recipe = ('manual', start_set, stop_keys, key_count)
1487
body = self._serialise_search_recipe(recipe)
1488
path = self.bzrdir._path_for_remote_call(self._client)
1490
if type(key) is not str:
1492
"key %r not a plain string" % (key,))
1493
verb = 'Repository.get_parent_map'
1494
args = (path, 'include-missing:') + tuple(keys)
1496
response = self._call_with_body_bytes_expecting_body(
1498
except errors.UnknownSmartMethod:
1499
# Server does not support this method, so get the whole graph.
1500
# Worse, we have to force a disconnection, because the server now
1501
# doesn't realise it has a body on the wire to consume, so the
1502
# only way to recover is to abandon the connection.
1504
'Server is too old for fast get_parent_map, reconnecting. '
1505
'(Upgrade the server to Bazaar 1.2 to avoid this)')
1507
# To avoid having to disconnect repeatedly, we keep track of the
1508
# fact the server doesn't understand remote methods added in 1.2.
1509
medium._remember_remote_is_before((1, 2))
1510
# Recurse just once and we should use the fallback code.
1511
return self._get_parent_map_rpc(keys)
1512
response_tuple, response_handler = response
1513
if response_tuple[0] not in ['ok']:
1514
response_handler.cancel_read_body()
1515
raise errors.UnexpectedSmartServerResponse(response_tuple)
1516
if response_tuple[0] == 'ok':
1517
coded = bz2.decompress(response_handler.read_body_bytes())
1519
# no revisions found
1521
lines = coded.split('\n')
1524
d = tuple(line.split())
1526
revision_graph[d[0]] = d[1:]
1529
if d[0].startswith('missing:'):
1531
self._unstacked_provider.note_missing_key(revid)
1533
# no parents - so give the Graph result
1535
revision_graph[d[0]] = (NULL_REVISION,)
1536
return revision_graph
1539
def get_signature_text(self, revision_id):
1541
return self._real_repository.get_signature_text(revision_id)
1544
def _get_inventory_xml(self, revision_id):
1546
return self._real_repository._get_inventory_xml(revision_id)
1548
def reconcile(self, other=None, thorough=False):
1550
return self._real_repository.reconcile(other=other, thorough=thorough)
1552
def all_revision_ids(self):
1554
return self._real_repository.all_revision_ids()
1557
def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1559
return self._real_repository.get_deltas_for_revisions(revisions,
1560
specific_fileids=specific_fileids)
1563
def get_revision_delta(self, revision_id, specific_fileids=None):
1565
return self._real_repository.get_revision_delta(revision_id,
1566
specific_fileids=specific_fileids)
1569
def revision_trees(self, revision_ids):
1571
return self._real_repository.revision_trees(revision_ids)
1574
def get_revision_reconcile(self, revision_id):
1576
return self._real_repository.get_revision_reconcile(revision_id)
1579
def check(self, revision_ids=None, callback_refs=None, check_repo=True):
1581
return self._real_repository.check(revision_ids=revision_ids,
1582
callback_refs=callback_refs, check_repo=check_repo)
1584
def copy_content_into(self, destination, revision_id=None):
1586
return self._real_repository.copy_content_into(
1587
destination, revision_id=revision_id)
1589
def _copy_repository_tarball(self, to_bzrdir, revision_id=None):
1590
# get a tarball of the remote repository, and copy from that into the
1592
from bzrlib import osutils
1594
# TODO: Maybe a progress bar while streaming the tarball?
1595
note("Copying repository content as tarball...")
1596
tar_file = self._get_tarball('bz2')
1597
if tar_file is None:
1599
destination = to_bzrdir.create_repository()
1601
tar = tarfile.open('repository', fileobj=tar_file,
1603
tmpdir = osutils.mkdtemp()
1605
_extract_tar(tar, tmpdir)
1606
tmp_bzrdir = BzrDir.open(tmpdir)
1607
tmp_repo = tmp_bzrdir.open_repository()
1608
tmp_repo.copy_content_into(destination, revision_id)
1610
osutils.rmtree(tmpdir)
1614
# TODO: Suggestion from john: using external tar is much faster than
1615
# python's tarfile library, but it may not work on windows.
1618
def inventories(self):
1619
"""Decorate the real repository for now.
1621
In the long term a full blown network facility is needed to
1622
avoid creating a real repository object locally.
1625
return self._real_repository.inventories
1628
def pack(self, hint=None, clean_obsolete_packs=False):
1629
"""Compress the data within the repository.
1631
This is not currently implemented within the smart server.
1634
return self._real_repository.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
1637
def revisions(self):
1638
"""Decorate the real repository for now.
1640
In the short term this should become a real object to intercept graph
1643
In the long term a full blown network facility is needed.
1646
return self._real_repository.revisions
1648
def set_make_working_trees(self, new_value):
1650
new_value_str = "True"
1652
new_value_str = "False"
1653
path = self.bzrdir._path_for_remote_call(self._client)
1655
response = self._call(
1656
'Repository.set_make_working_trees', path, new_value_str)
1657
except errors.UnknownSmartMethod:
1659
self._real_repository.set_make_working_trees(new_value)
1661
if response[0] != 'ok':
1662
raise errors.UnexpectedSmartServerResponse(response)
1665
def signatures(self):
1666
"""Decorate the real repository for now.
1668
In the long term a full blown network facility is needed to avoid
1669
creating a real repository object locally.
1672
return self._real_repository.signatures
1675
def sign_revision(self, revision_id, gpg_strategy):
1677
return self._real_repository.sign_revision(revision_id, gpg_strategy)
1681
"""Decorate the real repository for now.
1683
In the long term a full blown network facility is needed to avoid
1684
creating a real repository object locally.
1687
return self._real_repository.texts
1690
def get_revisions(self, revision_ids):
1692
return self._real_repository.get_revisions(revision_ids)
1694
def supports_rich_root(self):
1695
return self._format.rich_root_data
1697
def iter_reverse_revision_history(self, revision_id):
1699
return self._real_repository.iter_reverse_revision_history(revision_id)
1702
def _serializer(self):
1703
return self._format._serializer
1705
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1707
return self._real_repository.store_revision_signature(
1708
gpg_strategy, plaintext, revision_id)
1710
def add_signature_text(self, revision_id, signature):
1712
return self._real_repository.add_signature_text(revision_id, signature)
1714
def has_signature_for_revision_id(self, revision_id):
1716
return self._real_repository.has_signature_for_revision_id(revision_id)
1718
def item_keys_introduced_by(self, revision_ids, _files_pb=None):
1720
return self._real_repository.item_keys_introduced_by(revision_ids,
1721
_files_pb=_files_pb)
1723
def revision_graph_can_have_wrong_parents(self):
1724
# The answer depends on the remote repo format.
1726
return self._real_repository.revision_graph_can_have_wrong_parents()
1728
def _find_inconsistent_revision_parents(self, revisions_iterator=None):
1730
return self._real_repository._find_inconsistent_revision_parents(
1733
def _check_for_inconsistent_revision_parents(self):
1735
return self._real_repository._check_for_inconsistent_revision_parents()
1737
def _make_parents_provider(self, other=None):
1738
providers = [self._unstacked_provider]
1739
if other is not None:
1740
providers.insert(0, other)
1741
providers.extend(r._make_parents_provider() for r in
1742
self._fallback_repositories)
1743
return graph.StackedParentsProvider(providers)
1745
def _serialise_search_recipe(self, recipe):
1746
"""Serialise a graph search recipe.
1748
:param recipe: A search recipe (start, stop, count).
1749
:return: Serialised bytes.
1751
start_keys = ' '.join(recipe[1])
1752
stop_keys = ' '.join(recipe[2])
1753
count = str(recipe[3])
1754
return '\n'.join((start_keys, stop_keys, count))
1756
def _serialise_search_result(self, search_result):
1757
if isinstance(search_result, graph.PendingAncestryResult):
1758
parts = ['ancestry-of']
1759
parts.extend(search_result.heads)
1761
recipe = search_result.get_recipe()
1762
parts = [recipe[0], self._serialise_search_recipe(recipe)]
1763
return '\n'.join(parts)
1766
path = self.bzrdir._path_for_remote_call(self._client)
1768
response = self._call('PackRepository.autopack', path)
1769
except errors.UnknownSmartMethod:
1771
self._real_repository._pack_collection.autopack()
1774
if response[0] != 'ok':
1775
raise errors.UnexpectedSmartServerResponse(response)
1778
class RemoteStreamSink(repository.StreamSink):
1780
def _insert_real(self, stream, src_format, resume_tokens):
1781
self.target_repo._ensure_real()
1782
sink = self.target_repo._real_repository._get_sink()
1783
result = sink.insert_stream(stream, src_format, resume_tokens)
1785
self.target_repo.autopack()
1788
def insert_stream(self, stream, src_format, resume_tokens):
1789
target = self.target_repo
1790
target._unstacked_provider.missing_keys.clear()
1791
candidate_calls = [('Repository.insert_stream_1.19', (1, 19))]
1792
if target._lock_token:
1793
candidate_calls.append(('Repository.insert_stream_locked', (1, 14)))
1794
lock_args = (target._lock_token or '',)
1796
candidate_calls.append(('Repository.insert_stream', (1, 13)))
1798
client = target._client
1799
medium = client._medium
1800
path = target.bzrdir._path_for_remote_call(client)
1801
# Probe for the verb to use with an empty stream before sending the
1802
# real stream to it. We do this both to avoid the risk of sending a
1803
# large request that is then rejected, and because we don't want to
1804
# implement a way to buffer, rewind, or restart the stream.
1806
for verb, required_version in candidate_calls:
1807
if medium._is_remote_before(required_version):
1810
# We've already done the probing (and set _is_remote_before) on
1811
# a previous insert.
1814
byte_stream = smart_repo._stream_to_byte_stream([], src_format)
1816
response = client.call_with_body_stream(
1817
(verb, path, '') + lock_args, byte_stream)
1818
except errors.UnknownSmartMethod:
1819
medium._remember_remote_is_before(required_version)
1825
return self._insert_real(stream, src_format, resume_tokens)
1826
self._last_inv_record = None
1827
self._last_substream = None
1828
if required_version < (1, 19):
1829
# Remote side doesn't support inventory deltas. Wrap the stream to
1830
# make sure we don't send any. If the stream contains inventory
1831
# deltas we'll interrupt the smart insert_stream request and
1833
stream = self._stop_stream_if_inventory_delta(stream)
1834
byte_stream = smart_repo._stream_to_byte_stream(
1836
resume_tokens = ' '.join(resume_tokens)
1837
response = client.call_with_body_stream(
1838
(verb, path, resume_tokens) + lock_args, byte_stream)
1839
if response[0][0] not in ('ok', 'missing-basis'):
1840
raise errors.UnexpectedSmartServerResponse(response)
1841
if self._last_substream is not None:
1842
# The stream included an inventory-delta record, but the remote
1843
# side isn't new enough to support them. So we need to send the
1844
# rest of the stream via VFS.
1845
self.target_repo.refresh_data()
1846
return self._resume_stream_with_vfs(response, src_format)
1847
if response[0][0] == 'missing-basis':
1848
tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1849
resume_tokens = tokens
1850
return resume_tokens, set(missing_keys)
1852
self.target_repo.refresh_data()
1855
def _resume_stream_with_vfs(self, response, src_format):
1856
"""Resume sending a stream via VFS, first resending the record and
1857
substream that couldn't be sent via an insert_stream verb.
1859
if response[0][0] == 'missing-basis':
1860
tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1861
# Ignore missing_keys, we haven't finished inserting yet
1864
def resume_substream():
1865
# Yield the substream that was interrupted.
1866
for record in self._last_substream:
1868
self._last_substream = None
1869
def resume_stream():
1870
# Finish sending the interrupted substream
1871
yield ('inventory-deltas', resume_substream())
1872
# Then simply continue sending the rest of the stream.
1873
for substream_kind, substream in self._last_stream:
1874
yield substream_kind, substream
1875
return self._insert_real(resume_stream(), src_format, tokens)
1877
def _stop_stream_if_inventory_delta(self, stream):
1878
"""Normally this just lets the original stream pass-through unchanged.
1880
However if any 'inventory-deltas' substream occurs it will stop
1881
streaming, and store the interrupted substream and stream in
1882
self._last_substream and self._last_stream so that the stream can be
1883
resumed by _resume_stream_with_vfs.
1886
stream_iter = iter(stream)
1887
for substream_kind, substream in stream_iter:
1888
if substream_kind == 'inventory-deltas':
1889
self._last_substream = substream
1890
self._last_stream = stream_iter
1893
yield substream_kind, substream
1896
class RemoteStreamSource(repository.StreamSource):
1897
"""Stream data from a remote server."""
1899
def get_stream(self, search):
1900
if (self.from_repository._fallback_repositories and
1901
self.to_format._fetch_order == 'topological'):
1902
return self._real_stream(self.from_repository, search)
1905
repos = [self.from_repository]
1911
repos.extend(repo._fallback_repositories)
1912
sources.append(repo)
1913
return self.missing_parents_chain(search, sources)
1915
def get_stream_for_missing_keys(self, missing_keys):
1916
self.from_repository._ensure_real()
1917
real_repo = self.from_repository._real_repository
1918
real_source = real_repo._get_source(self.to_format)
1919
return real_source.get_stream_for_missing_keys(missing_keys)
1921
def _real_stream(self, repo, search):
1922
"""Get a stream for search from repo.
1924
This never called RemoteStreamSource.get_stream, and is a heler
1925
for RemoteStreamSource._get_stream to allow getting a stream
1926
reliably whether fallback back because of old servers or trying
1927
to stream from a non-RemoteRepository (which the stacked support
1930
source = repo._get_source(self.to_format)
1931
if isinstance(source, RemoteStreamSource):
1933
source = repo._real_repository._get_source(self.to_format)
1934
return source.get_stream(search)
1936
def _get_stream(self, repo, search):
1937
"""Core worker to get a stream from repo for search.
1939
This is used by both get_stream and the stacking support logic. It
1940
deliberately gets a stream for repo which does not need to be
1941
self.from_repository. In the event that repo is not Remote, or
1942
cannot do a smart stream, a fallback is made to the generic
1943
repository._get_stream() interface, via self._real_stream.
1945
In the event of stacking, streams from _get_stream will not
1946
contain all the data for search - this is normal (see get_stream).
1948
:param repo: A repository.
1949
:param search: A search.
1951
# Fallbacks may be non-smart
1952
if not isinstance(repo, RemoteRepository):
1953
return self._real_stream(repo, search)
1954
client = repo._client
1955
medium = client._medium
1956
path = repo.bzrdir._path_for_remote_call(client)
1957
search_bytes = repo._serialise_search_result(search)
1958
args = (path, self.to_format.network_name())
1960
('Repository.get_stream_1.19', (1, 19)),
1961
('Repository.get_stream', (1, 13))]
1963
for verb, version in candidate_verbs:
1964
if medium._is_remote_before(version):
1967
response = repo._call_with_body_bytes_expecting_body(
1968
verb, args, search_bytes)
1969
except errors.UnknownSmartMethod:
1970
medium._remember_remote_is_before(version)
1972
response_tuple, response_handler = response
1976
return self._real_stream(repo, search)
1977
if response_tuple[0] != 'ok':
1978
raise errors.UnexpectedSmartServerResponse(response_tuple)
1979
byte_stream = response_handler.read_streamed_body()
1980
src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
1981
if src_format.network_name() != repo._format.network_name():
1982
raise AssertionError(
1983
"Mismatched RemoteRepository and stream src %r, %r" % (
1984
src_format.network_name(), repo._format.network_name()))
1987
def missing_parents_chain(self, search, sources):
1988
"""Chain multiple streams together to handle stacking.
1990
:param search: The overall search to satisfy with streams.
1991
:param sources: A list of Repository objects to query.
1993
self.from_serialiser = self.from_repository._format._serializer
1994
self.seen_revs = set()
1995
self.referenced_revs = set()
1996
# If there are heads in the search, or the key count is > 0, we are not
1998
while not search.is_empty() and len(sources) > 1:
1999
source = sources.pop(0)
2000
stream = self._get_stream(source, search)
2001
for kind, substream in stream:
2002
if kind != 'revisions':
2003
yield kind, substream
2005
yield kind, self.missing_parents_rev_handler(substream)
2006
search = search.refine(self.seen_revs, self.referenced_revs)
2007
self.seen_revs = set()
2008
self.referenced_revs = set()
2009
if not search.is_empty():
2010
for kind, stream in self._get_stream(sources[0], search):
2013
def missing_parents_rev_handler(self, substream):
2014
for content in substream:
2015
revision_bytes = content.get_bytes_as('fulltext')
2016
revision = self.from_serialiser.read_revision_from_string(
2018
self.seen_revs.add(content.key[-1])
2019
self.referenced_revs.update(revision.parent_ids)
2023
class RemoteBranchLockableFiles(LockableFiles):
2024
"""A 'LockableFiles' implementation that talks to a smart server.
2026
This is not a public interface class.
2029
def __init__(self, bzrdir, _client):
2030
self.bzrdir = bzrdir
2031
self._client = _client
2032
self._need_find_modes = True
2033
LockableFiles.__init__(
2034
self, bzrdir.get_branch_transport(None),
2035
'lock', lockdir.LockDir)
2037
def _find_modes(self):
2038
# RemoteBranches don't let the client set the mode of control files.
2039
self._dir_mode = None
2040
self._file_mode = None
2043
class RemoteBranchFormat(branch.BranchFormat):
2045
def __init__(self, network_name=None):
2046
super(RemoteBranchFormat, self).__init__()
2047
self._matchingbzrdir = RemoteBzrDirFormat()
2048
self._matchingbzrdir.set_branch_format(self)
2049
self._custom_format = None
2050
self._network_name = network_name
2052
def __eq__(self, other):
2053
return (isinstance(other, RemoteBranchFormat) and
2054
self.__dict__ == other.__dict__)
2056
def _ensure_real(self):
2057
if self._custom_format is None:
2058
self._custom_format = branch.network_format_registry.get(
2061
def get_format_description(self):
2063
return 'Remote: ' + self._custom_format.get_format_description()
2065
def network_name(self):
2066
return self._network_name
2068
def open(self, a_bzrdir, name=None, ignore_fallbacks=False):
2069
return a_bzrdir.open_branch(name=name,
2070
ignore_fallbacks=ignore_fallbacks)
2072
def _vfs_initialize(self, a_bzrdir, name):
2073
# Initialisation when using a local bzrdir object, or a non-vfs init
2074
# method is not available on the server.
2075
# self._custom_format is always set - the start of initialize ensures
2077
if isinstance(a_bzrdir, RemoteBzrDir):
2078
a_bzrdir._ensure_real()
2079
result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2082
# We assume the bzrdir is parameterised; it may not be.
2083
result = self._custom_format.initialize(a_bzrdir, name)
2084
if (isinstance(a_bzrdir, RemoteBzrDir) and
2085
not isinstance(result, RemoteBranch)):
2086
result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2090
def initialize(self, a_bzrdir, name=None):
2091
# 1) get the network name to use.
2092
if self._custom_format:
2093
network_name = self._custom_format.network_name()
2095
# Select the current bzrlib default and ask for that.
2096
reference_bzrdir_format = bzrdir.format_registry.get('default')()
2097
reference_format = reference_bzrdir_format.get_branch_format()
2098
self._custom_format = reference_format
2099
network_name = reference_format.network_name()
2100
# Being asked to create on a non RemoteBzrDir:
2101
if not isinstance(a_bzrdir, RemoteBzrDir):
2102
return self._vfs_initialize(a_bzrdir, name=name)
2103
medium = a_bzrdir._client._medium
2104
if medium._is_remote_before((1, 13)):
2105
return self._vfs_initialize(a_bzrdir, name=name)
2106
# Creating on a remote bzr dir.
2107
# 2) try direct creation via RPC
2108
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2109
if name is not None:
2110
# XXX JRV20100304: Support creating colocated branches
2111
raise errors.NoColocatedBranchSupport(self)
2112
verb = 'BzrDir.create_branch'
2114
response = a_bzrdir._call(verb, path, network_name)
2115
except errors.UnknownSmartMethod:
2116
# Fallback - use vfs methods
2117
medium._remember_remote_is_before((1, 13))
2118
return self._vfs_initialize(a_bzrdir, name=name)
2119
if response[0] != 'ok':
2120
raise errors.UnexpectedSmartServerResponse(response)
2121
# Turn the response into a RemoteRepository object.
2122
format = RemoteBranchFormat(network_name=response[1])
2123
repo_format = response_tuple_to_repo_format(response[3:])
2124
if response[2] == '':
2125
repo_bzrdir = a_bzrdir
2127
repo_bzrdir = RemoteBzrDir(
2128
a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
2130
remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2131
remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2132
format=format, setup_stacking=False, name=name)
2133
# XXX: We know this is a new branch, so it must have revno 0, revid
2134
# NULL_REVISION. Creating the branch locked would make this be unable
2135
# to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2136
remote_branch._last_revision_info_cache = 0, NULL_REVISION
2137
return remote_branch
2139
def make_tags(self, branch):
2141
return self._custom_format.make_tags(branch)
2143
def supports_tags(self):
2144
# Remote branches might support tags, but we won't know until we
2145
# access the real remote branch.
2147
return self._custom_format.supports_tags()
2149
def supports_stacking(self):
2151
return self._custom_format.supports_stacking()
2153
def supports_set_append_revisions_only(self):
2155
return self._custom_format.supports_set_append_revisions_only()
2158
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
2159
"""Branch stored on a server accessed by HPSS RPC.
2161
At the moment most operations are mapped down to simple file operations.
2164
def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2165
_client=None, format=None, setup_stacking=True, name=None):
2166
"""Create a RemoteBranch instance.
2168
:param real_branch: An optional local implementation of the branch
2169
format, usually accessing the data via the VFS.
2170
:param _client: Private parameter for testing.
2171
:param format: A RemoteBranchFormat object, None to create one
2172
automatically. If supplied it should have a network_name already
2174
:param setup_stacking: If True make an RPC call to determine the
2175
stacked (or not) status of the branch. If False assume the branch
2177
:param name: Colocated branch name
2179
# We intentionally don't call the parent class's __init__, because it
2180
# will try to assign to self.tags, which is a property in this subclass.
2181
# And the parent's __init__ doesn't do much anyway.
2182
self.bzrdir = remote_bzrdir
2183
if _client is not None:
2184
self._client = _client
2186
self._client = remote_bzrdir._client
2187
self.repository = remote_repository
2188
if real_branch is not None:
2189
self._real_branch = real_branch
2190
# Give the remote repository the matching real repo.
2191
real_repo = self._real_branch.repository
2192
if isinstance(real_repo, RemoteRepository):
2193
real_repo._ensure_real()
2194
real_repo = real_repo._real_repository
2195
self.repository._set_real_repository(real_repo)
2196
# Give the branch the remote repository to let fast-pathing happen.
2197
self._real_branch.repository = self.repository
2199
self._real_branch = None
2200
# Fill out expected attributes of branch for bzrlib API users.
2201
self._clear_cached_state()
2202
# TODO: deprecate self.base in favor of user_url
2203
self.base = self.bzrdir.user_url
2205
self._control_files = None
2206
self._lock_mode = None
2207
self._lock_token = None
2208
self._repo_lock_token = None
2209
self._lock_count = 0
2210
self._leave_lock = False
2211
# Setup a format: note that we cannot call _ensure_real until all the
2212
# attributes above are set: This code cannot be moved higher up in this
2215
self._format = RemoteBranchFormat()
2216
if real_branch is not None:
2217
self._format._network_name = \
2218
self._real_branch._format.network_name()
2220
self._format = format
2221
# when we do _ensure_real we may need to pass ignore_fallbacks to the
2222
# branch.open_branch method.
2223
self._real_ignore_fallbacks = not setup_stacking
2224
if not self._format._network_name:
2225
# Did not get from open_branchV2 - old server.
2227
self._format._network_name = \
2228
self._real_branch._format.network_name()
2229
self.tags = self._format.make_tags(self)
2230
# The base class init is not called, so we duplicate this:
2231
hooks = branch.Branch.hooks['open']
2234
self._is_stacked = False
2236
self._setup_stacking()
2238
def _setup_stacking(self):
2239
# configure stacking into the remote repository, by reading it from
2242
fallback_url = self.get_stacked_on_url()
2243
except (errors.NotStacked, errors.UnstackableBranchFormat,
2244
errors.UnstackableRepositoryFormat), e:
2246
self._is_stacked = True
2247
self._activate_fallback_location(fallback_url)
2249
def _get_config(self):
2250
return RemoteBranchConfig(self)
2252
def _get_real_transport(self):
2253
# if we try vfs access, return the real branch's vfs transport
2255
return self._real_branch._transport
2257
_transport = property(_get_real_transport)
2260
return "%s(%s)" % (self.__class__.__name__, self.base)
2264
def _ensure_real(self):
2265
"""Ensure that there is a _real_branch set.
2267
Used before calls to self._real_branch.
2269
if self._real_branch is None:
2270
if not vfs.vfs_enabled():
2271
raise AssertionError('smart server vfs must be enabled '
2272
'to use vfs implementation')
2273
self.bzrdir._ensure_real()
2274
self._real_branch = self.bzrdir._real_bzrdir.open_branch(
2275
ignore_fallbacks=self._real_ignore_fallbacks, name=self._name)
2276
if self.repository._real_repository is None:
2277
# Give the remote repository the matching real repo.
2278
real_repo = self._real_branch.repository
2279
if isinstance(real_repo, RemoteRepository):
2280
real_repo._ensure_real()
2281
real_repo = real_repo._real_repository
2282
self.repository._set_real_repository(real_repo)
2283
# Give the real branch the remote repository to let fast-pathing
2285
self._real_branch.repository = self.repository
2286
if self._lock_mode == 'r':
2287
self._real_branch.lock_read()
2288
elif self._lock_mode == 'w':
2289
self._real_branch.lock_write(token=self._lock_token)
2291
def _translate_error(self, err, **context):
2292
self.repository._translate_error(err, branch=self, **context)
2294
def _clear_cached_state(self):
2295
super(RemoteBranch, self)._clear_cached_state()
2296
if self._real_branch is not None:
2297
self._real_branch._clear_cached_state()
2299
def _clear_cached_state_of_remote_branch_only(self):
2300
"""Like _clear_cached_state, but doesn't clear the cache of
2303
This is useful when falling back to calling a method of
2304
self._real_branch that changes state. In that case the underlying
2305
branch changes, so we need to invalidate this RemoteBranch's cache of
2306
it. However, there's no need to invalidate the _real_branch's cache
2307
too, in fact doing so might harm performance.
2309
super(RemoteBranch, self)._clear_cached_state()
2312
def control_files(self):
2313
# Defer actually creating RemoteBranchLockableFiles until its needed,
2314
# because it triggers an _ensure_real that we otherwise might not need.
2315
if self._control_files is None:
2316
self._control_files = RemoteBranchLockableFiles(
2317
self.bzrdir, self._client)
2318
return self._control_files
2320
def _get_checkout_format(self):
2322
return self._real_branch._get_checkout_format()
2324
def get_physical_lock_status(self):
2325
"""See Branch.get_physical_lock_status()."""
2326
# should be an API call to the server, as branches must be lockable.
2328
return self._real_branch.get_physical_lock_status()
2330
def get_stacked_on_url(self):
2331
"""Get the URL this branch is stacked against.
2333
:raises NotStacked: If the branch is not stacked.
2334
:raises UnstackableBranchFormat: If the branch does not support
2336
:raises UnstackableRepositoryFormat: If the repository does not support
2340
# there may not be a repository yet, so we can't use
2341
# self._translate_error, so we can't use self._call either.
2342
response = self._client.call('Branch.get_stacked_on_url',
2343
self._remote_path())
2344
except errors.ErrorFromSmartServer, err:
2345
# there may not be a repository yet, so we can't call through
2346
# its _translate_error
2347
_translate_error(err, branch=self)
2348
except errors.UnknownSmartMethod, err:
2350
return self._real_branch.get_stacked_on_url()
2351
if response[0] != 'ok':
2352
raise errors.UnexpectedSmartServerResponse(response)
2355
def set_stacked_on_url(self, url):
2356
branch.Branch.set_stacked_on_url(self, url)
2358
self._is_stacked = False
2360
self._is_stacked = True
2362
def _vfs_get_tags_bytes(self):
2364
return self._real_branch._get_tags_bytes()
2366
def _get_tags_bytes(self):
2367
medium = self._client._medium
2368
if medium._is_remote_before((1, 13)):
2369
return self._vfs_get_tags_bytes()
2371
response = self._call('Branch.get_tags_bytes', self._remote_path())
2372
except errors.UnknownSmartMethod:
2373
medium._remember_remote_is_before((1, 13))
2374
return self._vfs_get_tags_bytes()
2377
def _vfs_set_tags_bytes(self, bytes):
2379
return self._real_branch._set_tags_bytes(bytes)
2381
def _set_tags_bytes(self, bytes):
2382
medium = self._client._medium
2383
if medium._is_remote_before((1, 18)):
2384
self._vfs_set_tags_bytes(bytes)
2388
self._remote_path(), self._lock_token, self._repo_lock_token)
2389
response = self._call_with_body_bytes(
2390
'Branch.set_tags_bytes', args, bytes)
2391
except errors.UnknownSmartMethod:
2392
medium._remember_remote_is_before((1, 18))
2393
self._vfs_set_tags_bytes(bytes)
2395
def lock_read(self):
2396
"""Lock the branch for read operations.
2398
:return: A bzrlib.lock.LogicalLockResult.
2400
self.repository.lock_read()
2401
if not self._lock_mode:
2402
self._note_lock('r')
2403
self._lock_mode = 'r'
2404
self._lock_count = 1
2405
if self._real_branch is not None:
2406
self._real_branch.lock_read()
2408
self._lock_count += 1
2409
return lock.LogicalLockResult(self.unlock)
2411
def _remote_lock_write(self, token):
2413
branch_token = repo_token = ''
2415
branch_token = token
2416
repo_token = self.repository.lock_write().repository_token
2417
self.repository.unlock()
2418
err_context = {'token': token}
2419
response = self._call(
2420
'Branch.lock_write', self._remote_path(), branch_token,
2421
repo_token or '', **err_context)
2422
if response[0] != 'ok':
2423
raise errors.UnexpectedSmartServerResponse(response)
2424
ok, branch_token, repo_token = response
2425
return branch_token, repo_token
2427
def lock_write(self, token=None):
2428
if not self._lock_mode:
2429
self._note_lock('w')
2430
# Lock the branch and repo in one remote call.
2431
remote_tokens = self._remote_lock_write(token)
2432
self._lock_token, self._repo_lock_token = remote_tokens
2433
if not self._lock_token:
2434
raise SmartProtocolError('Remote server did not return a token!')
2435
# Tell the self.repository object that it is locked.
2436
self.repository.lock_write(
2437
self._repo_lock_token, _skip_rpc=True)
2439
if self._real_branch is not None:
2440
self._real_branch.lock_write(token=self._lock_token)
2441
if token is not None:
2442
self._leave_lock = True
2444
self._leave_lock = False
2445
self._lock_mode = 'w'
2446
self._lock_count = 1
2447
elif self._lock_mode == 'r':
2448
raise errors.ReadOnlyTransaction
2450
if token is not None:
2451
# A token was given to lock_write, and we're relocking, so
2452
# check that the given token actually matches the one we
2454
if token != self._lock_token:
2455
raise errors.TokenMismatch(token, self._lock_token)
2456
self._lock_count += 1
2457
# Re-lock the repository too.
2458
self.repository.lock_write(self._repo_lock_token)
2459
return BranchWriteLockResult(self.unlock, self._lock_token or None)
2461
def _unlock(self, branch_token, repo_token):
2462
err_context = {'token': str((branch_token, repo_token))}
2463
response = self._call(
2464
'Branch.unlock', self._remote_path(), branch_token,
2465
repo_token or '', **err_context)
2466
if response == ('ok',):
2468
raise errors.UnexpectedSmartServerResponse(response)
2470
@only_raises(errors.LockNotHeld, errors.LockBroken)
2473
self._lock_count -= 1
2474
if not self._lock_count:
2475
self._clear_cached_state()
2476
mode = self._lock_mode
2477
self._lock_mode = None
2478
if self._real_branch is not None:
2479
if (not self._leave_lock and mode == 'w' and
2480
self._repo_lock_token):
2481
# If this RemoteBranch will remove the physical lock
2482
# for the repository, make sure the _real_branch
2483
# doesn't do it first. (Because the _real_branch's
2484
# repository is set to be the RemoteRepository.)
2485
self._real_branch.repository.leave_lock_in_place()
2486
self._real_branch.unlock()
2488
# Only write-locked branched need to make a remote method
2489
# call to perform the unlock.
2491
if not self._lock_token:
2492
raise AssertionError('Locked, but no token!')
2493
branch_token = self._lock_token
2494
repo_token = self._repo_lock_token
2495
self._lock_token = None
2496
self._repo_lock_token = None
2497
if not self._leave_lock:
2498
self._unlock(branch_token, repo_token)
2500
self.repository.unlock()
2502
def break_lock(self):
2504
return self._real_branch.break_lock()
2506
def leave_lock_in_place(self):
2507
if not self._lock_token:
2508
raise NotImplementedError(self.leave_lock_in_place)
2509
self._leave_lock = True
2511
def dont_leave_lock_in_place(self):
2512
if not self._lock_token:
2513
raise NotImplementedError(self.dont_leave_lock_in_place)
2514
self._leave_lock = False
2517
def get_rev_id(self, revno, history=None):
2519
return _mod_revision.NULL_REVISION
2520
last_revision_info = self.last_revision_info()
2521
ok, result = self.repository.get_rev_id_for_revno(
2522
revno, last_revision_info)
2525
missing_parent = result[1]
2526
# Either the revision named by the server is missing, or its parent
2527
# is. Call get_parent_map to determine which, so that we report a
2529
parent_map = self.repository.get_parent_map([missing_parent])
2530
if missing_parent in parent_map:
2531
missing_parent = parent_map[missing_parent]
2532
raise errors.RevisionNotPresent(missing_parent, self.repository)
2534
def _last_revision_info(self):
2535
response = self._call('Branch.last_revision_info', self._remote_path())
2536
if response[0] != 'ok':
2537
raise SmartProtocolError('unexpected response code %s' % (response,))
2538
revno = int(response[1])
2539
last_revision = response[2]
2540
return (revno, last_revision)
2542
def _gen_revision_history(self):
2543
"""See Branch._gen_revision_history()."""
2544
if self._is_stacked:
2546
return self._real_branch._gen_revision_history()
2547
response_tuple, response_handler = self._call_expecting_body(
2548
'Branch.revision_history', self._remote_path())
2549
if response_tuple[0] != 'ok':
2550
raise errors.UnexpectedSmartServerResponse(response_tuple)
2551
result = response_handler.read_body_bytes().split('\x00')
2556
def _remote_path(self):
2557
return self.bzrdir._path_for_remote_call(self._client)
2559
def _set_last_revision_descendant(self, revision_id, other_branch,
2560
allow_diverged=False, allow_overwrite_descendant=False):
2561
# This performs additional work to meet the hook contract; while its
2562
# undesirable, we have to synthesise the revno to call the hook, and
2563
# not calling the hook is worse as it means changes can't be prevented.
2564
# Having calculated this though, we can't just call into
2565
# set_last_revision_info as a simple call, because there is a set_rh
2566
# hook that some folk may still be using.
2567
old_revno, old_revid = self.last_revision_info()
2568
history = self._lefthand_history(revision_id)
2569
self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2570
err_context = {'other_branch': other_branch}
2571
response = self._call('Branch.set_last_revision_ex',
2572
self._remote_path(), self._lock_token, self._repo_lock_token,
2573
revision_id, int(allow_diverged), int(allow_overwrite_descendant),
2575
self._clear_cached_state()
2576
if len(response) != 3 and response[0] != 'ok':
2577
raise errors.UnexpectedSmartServerResponse(response)
2578
new_revno, new_revision_id = response[1:]
2579
self._last_revision_info_cache = new_revno, new_revision_id
2580
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2581
if self._real_branch is not None:
2582
cache = new_revno, new_revision_id
2583
self._real_branch._last_revision_info_cache = cache
2585
def _set_last_revision(self, revision_id):
2586
old_revno, old_revid = self.last_revision_info()
2587
# This performs additional work to meet the hook contract; while its
2588
# undesirable, we have to synthesise the revno to call the hook, and
2589
# not calling the hook is worse as it means changes can't be prevented.
2590
# Having calculated this though, we can't just call into
2591
# set_last_revision_info as a simple call, because there is a set_rh
2592
# hook that some folk may still be using.
2593
history = self._lefthand_history(revision_id)
2594
self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2595
self._clear_cached_state()
2596
response = self._call('Branch.set_last_revision',
2597
self._remote_path(), self._lock_token, self._repo_lock_token,
2599
if response != ('ok',):
2600
raise errors.UnexpectedSmartServerResponse(response)
2601
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2604
def set_revision_history(self, rev_history):
2605
# Send just the tip revision of the history; the server will generate
2606
# the full history from that. If the revision doesn't exist in this
2607
# branch, NoSuchRevision will be raised.
2608
if rev_history == []:
2611
rev_id = rev_history[-1]
2612
self._set_last_revision(rev_id)
2613
for hook in branch.Branch.hooks['set_rh']:
2614
hook(self, rev_history)
2615
self._cache_revision_history(rev_history)
2617
def _get_parent_location(self):
2618
medium = self._client._medium
2619
if medium._is_remote_before((1, 13)):
2620
return self._vfs_get_parent_location()
2622
response = self._call('Branch.get_parent', self._remote_path())
2623
except errors.UnknownSmartMethod:
2624
medium._remember_remote_is_before((1, 13))
2625
return self._vfs_get_parent_location()
2626
if len(response) != 1:
2627
raise errors.UnexpectedSmartServerResponse(response)
2628
parent_location = response[0]
2629
if parent_location == '':
2631
return parent_location
2633
def _vfs_get_parent_location(self):
2635
return self._real_branch._get_parent_location()
2637
def _set_parent_location(self, url):
2638
medium = self._client._medium
2639
if medium._is_remote_before((1, 15)):
2640
return self._vfs_set_parent_location(url)
2642
call_url = url or ''
2643
if type(call_url) is not str:
2644
raise AssertionError('url must be a str or None (%s)' % url)
2645
response = self._call('Branch.set_parent_location',
2646
self._remote_path(), self._lock_token, self._repo_lock_token,
2648
except errors.UnknownSmartMethod:
2649
medium._remember_remote_is_before((1, 15))
2650
return self._vfs_set_parent_location(url)
2652
raise errors.UnexpectedSmartServerResponse(response)
2654
def _vfs_set_parent_location(self, url):
2656
return self._real_branch._set_parent_location(url)
2659
def pull(self, source, overwrite=False, stop_revision=None,
2661
self._clear_cached_state_of_remote_branch_only()
2663
return self._real_branch.pull(
2664
source, overwrite=overwrite, stop_revision=stop_revision,
2665
_override_hook_target=self, **kwargs)
2668
def push(self, target, overwrite=False, stop_revision=None):
2670
return self._real_branch.push(
2671
target, overwrite=overwrite, stop_revision=stop_revision,
2672
_override_hook_source_branch=self)
2674
def is_locked(self):
2675
return self._lock_count >= 1
2678
def revision_id_to_revno(self, revision_id):
2680
return self._real_branch.revision_id_to_revno(revision_id)
2683
def set_last_revision_info(self, revno, revision_id):
2684
# XXX: These should be returned by the set_last_revision_info verb
2685
old_revno, old_revid = self.last_revision_info()
2686
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2687
revision_id = ensure_null(revision_id)
2689
response = self._call('Branch.set_last_revision_info',
2690
self._remote_path(), self._lock_token, self._repo_lock_token,
2691
str(revno), revision_id)
2692
except errors.UnknownSmartMethod:
2694
self._clear_cached_state_of_remote_branch_only()
2695
self._real_branch.set_last_revision_info(revno, revision_id)
2696
self._last_revision_info_cache = revno, revision_id
2698
if response == ('ok',):
2699
self._clear_cached_state()
2700
self._last_revision_info_cache = revno, revision_id
2701
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2702
# Update the _real_branch's cache too.
2703
if self._real_branch is not None:
2704
cache = self._last_revision_info_cache
2705
self._real_branch._last_revision_info_cache = cache
2707
raise errors.UnexpectedSmartServerResponse(response)
2710
def generate_revision_history(self, revision_id, last_rev=None,
2712
medium = self._client._medium
2713
if not medium._is_remote_before((1, 6)):
2714
# Use a smart method for 1.6 and above servers
2716
self._set_last_revision_descendant(revision_id, other_branch,
2717
allow_diverged=True, allow_overwrite_descendant=True)
2719
except errors.UnknownSmartMethod:
2720
medium._remember_remote_is_before((1, 6))
2721
self._clear_cached_state_of_remote_branch_only()
2722
self.set_revision_history(self._lefthand_history(revision_id,
2723
last_rev=last_rev,other_branch=other_branch))
2725
def set_push_location(self, location):
2727
return self._real_branch.set_push_location(location)
2730
class RemoteConfig(object):
2731
"""A Config that reads and writes from smart verbs.
2733
It is a low-level object that considers config data to be name/value pairs
2734
that may be associated with a section. Assigning meaning to the these
2735
values is done at higher levels like bzrlib.config.TreeConfig.
2738
def get_option(self, name, section=None, default=None):
2739
"""Return the value associated with a named option.
2741
:param name: The name of the value
2742
:param section: The section the option is in (if any)
2743
:param default: The value to return if the value is not set
2744
:return: The value or default value
2747
configobj = self._get_configobj()
2749
section_obj = configobj
2752
section_obj = configobj[section]
2755
return section_obj.get(name, default)
2756
except errors.UnknownSmartMethod:
2757
return self._vfs_get_option(name, section, default)
2759
def _response_to_configobj(self, response):
2760
if len(response[0]) and response[0][0] != 'ok':
2761
raise errors.UnexpectedSmartServerResponse(response)
2762
lines = response[1].read_body_bytes().splitlines()
2763
return config.ConfigObj(lines, encoding='utf-8')
2766
class RemoteBranchConfig(RemoteConfig):
2767
"""A RemoteConfig for Branches."""
2769
def __init__(self, branch):
2770
self._branch = branch
2772
def _get_configobj(self):
2773
path = self._branch._remote_path()
2774
response = self._branch._client.call_expecting_body(
2775
'Branch.get_config_file', path)
2776
return self._response_to_configobj(response)
2778
def set_option(self, value, name, section=None):
2779
"""Set the value associated with a named option.
2781
:param value: The value to set
2782
:param name: The name of the value to set
2783
:param section: The section the option is in (if any)
2785
medium = self._branch._client._medium
2786
if medium._is_remote_before((1, 14)):
2787
return self._vfs_set_option(value, name, section)
2789
path = self._branch._remote_path()
2790
response = self._branch._client.call('Branch.set_config_option',
2791
path, self._branch._lock_token, self._branch._repo_lock_token,
2792
value.encode('utf8'), name, section or '')
2793
except errors.UnknownSmartMethod:
2794
medium._remember_remote_is_before((1, 14))
2795
return self._vfs_set_option(value, name, section)
2797
raise errors.UnexpectedSmartServerResponse(response)
2799
def _real_object(self):
2800
self._branch._ensure_real()
2801
return self._branch._real_branch
2803
def _vfs_set_option(self, value, name, section=None):
2804
return self._real_object()._get_config().set_option(
2805
value, name, section)
2808
class RemoteBzrDirConfig(RemoteConfig):
2809
"""A RemoteConfig for BzrDirs."""
2811
def __init__(self, bzrdir):
2812
self._bzrdir = bzrdir
2814
def _get_configobj(self):
2815
medium = self._bzrdir._client._medium
2816
verb = 'BzrDir.get_config_file'
2817
if medium._is_remote_before((1, 15)):
2818
raise errors.UnknownSmartMethod(verb)
2819
path = self._bzrdir._path_for_remote_call(self._bzrdir._client)
2820
response = self._bzrdir._call_expecting_body(
2822
return self._response_to_configobj(response)
2824
def _vfs_get_option(self, name, section, default):
2825
return self._real_object()._get_config().get_option(
2826
name, section, default)
2828
def set_option(self, value, name, section=None):
2829
"""Set the value associated with a named option.
2831
:param value: The value to set
2832
:param name: The name of the value to set
2833
:param section: The section the option is in (if any)
2835
return self._real_object()._get_config().set_option(
2836
value, name, section)
2838
def _real_object(self):
2839
self._bzrdir._ensure_real()
2840
return self._bzrdir._real_bzrdir
2844
def _extract_tar(tar, to_dir):
2845
"""Extract all the contents of a tarfile object.
2847
A replacement for extractall, which is not present in python2.4
2850
tar.extract(tarinfo, to_dir)
2853
def _translate_error(err, **context):
2854
"""Translate an ErrorFromSmartServer into a more useful error.
2856
Possible context keys:
2864
If the error from the server doesn't match a known pattern, then
2865
UnknownErrorFromSmartServer is raised.
2869
return context[name]
2870
except KeyError, key_err:
2871
mutter('Missing key %r in context %r', key_err.args[0], context)
2874
"""Get the path from the context if present, otherwise use first error
2878
return context['path']
2879
except KeyError, key_err:
2881
return err.error_args[0]
2882
except IndexError, idx_err:
2884
'Missing key %r in context %r', key_err.args[0], context)
2887
if err.error_verb == 'IncompatibleRepositories':
2888
raise errors.IncompatibleRepositories(err.error_args[0],
2889
err.error_args[1], err.error_args[2])
2890
elif err.error_verb == 'NoSuchRevision':
2891
raise NoSuchRevision(find('branch'), err.error_args[0])
2892
elif err.error_verb == 'nosuchrevision':
2893
raise NoSuchRevision(find('repository'), err.error_args[0])
2894
elif err.error_verb == 'nobranch':
2895
if len(err.error_args) >= 1:
2896
extra = err.error_args[0]
2899
raise errors.NotBranchError(path=find('bzrdir').root_transport.base,
2901
elif err.error_verb == 'norepository':
2902
raise errors.NoRepositoryPresent(find('bzrdir'))
2903
elif err.error_verb == 'LockContention':
2904
raise errors.LockContention('(remote lock)')
2905
elif err.error_verb == 'UnlockableTransport':
2906
raise errors.UnlockableTransport(find('bzrdir').root_transport)
2907
elif err.error_verb == 'LockFailed':
2908
raise errors.LockFailed(err.error_args[0], err.error_args[1])
2909
elif err.error_verb == 'TokenMismatch':
2910
raise errors.TokenMismatch(find('token'), '(remote token)')
2911
elif err.error_verb == 'Diverged':
2912
raise errors.DivergedBranches(find('branch'), find('other_branch'))
2913
elif err.error_verb == 'TipChangeRejected':
2914
raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
2915
elif err.error_verb == 'UnstackableBranchFormat':
2916
raise errors.UnstackableBranchFormat(*err.error_args)
2917
elif err.error_verb == 'UnstackableRepositoryFormat':
2918
raise errors.UnstackableRepositoryFormat(*err.error_args)
2919
elif err.error_verb == 'NotStacked':
2920
raise errors.NotStacked(branch=find('branch'))
2921
elif err.error_verb == 'PermissionDenied':
2923
if len(err.error_args) >= 2:
2924
extra = err.error_args[1]
2927
raise errors.PermissionDenied(path, extra=extra)
2928
elif err.error_verb == 'ReadError':
2930
raise errors.ReadError(path)
2931
elif err.error_verb == 'NoSuchFile':
2933
raise errors.NoSuchFile(path)
2934
elif err.error_verb == 'FileExists':
2935
raise errors.FileExists(err.error_args[0])
2936
elif err.error_verb == 'DirectoryNotEmpty':
2937
raise errors.DirectoryNotEmpty(err.error_args[0])
2938
elif err.error_verb == 'ShortReadvError':
2939
args = err.error_args
2940
raise errors.ShortReadvError(
2941
args[0], int(args[1]), int(args[2]), int(args[3]))
2942
elif err.error_verb in ('UnicodeEncodeError', 'UnicodeDecodeError'):
2943
encoding = str(err.error_args[0]) # encoding must always be a string
2944
val = err.error_args[1]
2945
start = int(err.error_args[2])
2946
end = int(err.error_args[3])
2947
reason = str(err.error_args[4]) # reason must always be a string
2948
if val.startswith('u:'):
2949
val = val[2:].decode('utf-8')
2950
elif val.startswith('s:'):
2951
val = val[2:].decode('base64')
2952
if err.error_verb == 'UnicodeDecodeError':
2953
raise UnicodeDecodeError(encoding, val, start, end, reason)
2954
elif err.error_verb == 'UnicodeEncodeError':
2955
raise UnicodeEncodeError(encoding, val, start, end, reason)
2956
elif err.error_verb == 'ReadOnlyError':
2957
raise errors.TransportNotPossible('readonly transport')
2958
raise errors.UnknownErrorFromSmartServer(err)
added
removed
bzrlib/remote.py
