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, name=None):
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(name=name)
284
def get_branch_reference(self, name=None):
285
"""See BzrDir.get_branch_reference()."""
287
# XXX JRV20100304: Support opening colocated branches
288
raise errors.NoColocatedBranchSupport(self)
289
response = self._get_branch_reference()
290
if response[0] == 'ref':
295
def _get_branch_reference(self):
296
path = self._path_for_remote_call(self._client)
297
medium = self._client._medium
299
('BzrDir.open_branchV3', (2, 1)),
300
('BzrDir.open_branchV2', (1, 13)),
301
('BzrDir.open_branch', None),
303
for verb, required_version in candidate_calls:
304
if required_version and medium._is_remote_before(required_version):
307
response = self._call(verb, path)
308
except errors.UnknownSmartMethod:
309
if required_version is None:
311
medium._remember_remote_is_before(required_version)
314
if verb == 'BzrDir.open_branch':
315
if response[0] != 'ok':
316
raise errors.UnexpectedSmartServerResponse(response)
317
if response[1] != '':
318
return ('ref', response[1])
320
return ('branch', '')
321
if response[0] not in ('ref', 'branch'):
322
raise errors.UnexpectedSmartServerResponse(response)
325
def _get_tree_branch(self, name=None):
326
"""See BzrDir._get_tree_branch()."""
327
return None, self.open_branch(name=name)
329
def open_branch(self, name=None, unsupported=False,
330
ignore_fallbacks=False):
332
raise NotImplementedError('unsupported flag support not implemented yet.')
333
if self._next_open_branch_result is not None:
334
# See create_branch for details.
335
result = self._next_open_branch_result
336
self._next_open_branch_result = None
338
response = self._get_branch_reference()
339
if response[0] == 'ref':
340
# a branch reference, use the existing BranchReference logic.
341
format = BranchReferenceFormat()
342
return format.open(self, name=name, _found=True,
343
location=response[1], ignore_fallbacks=ignore_fallbacks)
344
branch_format_name = response[1]
345
if not branch_format_name:
346
branch_format_name = None
347
format = RemoteBranchFormat(network_name=branch_format_name)
348
return RemoteBranch(self, self.find_repository(), format=format,
349
setup_stacking=not ignore_fallbacks, name=name)
351
def _open_repo_v1(self, path):
352
verb = 'BzrDir.find_repository'
353
response = self._call(verb, path)
354
if response[0] != 'ok':
355
raise errors.UnexpectedSmartServerResponse(response)
356
# servers that only support the v1 method don't support external
359
repo = self._real_bzrdir.open_repository()
360
response = response + ('no', repo._format.network_name())
361
return response, repo
363
def _open_repo_v2(self, path):
364
verb = 'BzrDir.find_repositoryV2'
365
response = self._call(verb, path)
366
if response[0] != 'ok':
367
raise errors.UnexpectedSmartServerResponse(response)
369
repo = self._real_bzrdir.open_repository()
370
response = response + (repo._format.network_name(),)
371
return response, repo
373
def _open_repo_v3(self, path):
374
verb = 'BzrDir.find_repositoryV3'
375
medium = self._client._medium
376
if medium._is_remote_before((1, 13)):
377
raise errors.UnknownSmartMethod(verb)
379
response = self._call(verb, path)
380
except errors.UnknownSmartMethod:
381
medium._remember_remote_is_before((1, 13))
383
if response[0] != 'ok':
384
raise errors.UnexpectedSmartServerResponse(response)
385
return response, None
387
def open_repository(self):
388
path = self._path_for_remote_call(self._client)
390
for probe in [self._open_repo_v3, self._open_repo_v2,
393
response, real_repo = probe(path)
395
except errors.UnknownSmartMethod:
398
raise errors.UnknownSmartMethod('BzrDir.find_repository{3,2,}')
399
if response[0] != 'ok':
400
raise errors.UnexpectedSmartServerResponse(response)
401
if len(response) != 6:
402
raise SmartProtocolError('incorrect response length %s' % (response,))
403
if response[1] == '':
404
# repo is at this dir.
405
format = response_tuple_to_repo_format(response[2:])
406
# Used to support creating a real format instance when needed.
407
format._creating_bzrdir = self
408
remote_repo = RemoteRepository(self, format)
409
format._creating_repo = remote_repo
410
if real_repo is not None:
411
remote_repo._set_real_repository(real_repo)
414
raise errors.NoRepositoryPresent(self)
416
def has_workingtree(self):
417
if self._has_working_tree is None:
419
self._has_working_tree = self._real_bzrdir.has_workingtree()
420
return self._has_working_tree
422
def open_workingtree(self, recommend_upgrade=True):
423
if self.has_workingtree():
424
raise errors.NotLocalUrl(self.root_transport)
426
raise errors.NoWorkingTree(self.root_transport.base)
428
def _path_for_remote_call(self, client):
429
"""Return the path to be used for this bzrdir in a remote call."""
430
return client.remote_path_from_transport(self.root_transport)
432
def get_branch_transport(self, branch_format, name=None):
434
return self._real_bzrdir.get_branch_transport(branch_format, name=name)
436
def get_repository_transport(self, repository_format):
438
return self._real_bzrdir.get_repository_transport(repository_format)
440
def get_workingtree_transport(self, workingtree_format):
442
return self._real_bzrdir.get_workingtree_transport(workingtree_format)
444
def can_convert_format(self):
445
"""Upgrading of remote bzrdirs is not supported yet."""
448
def needs_format_conversion(self, format=None):
449
"""Upgrading of remote bzrdirs is not supported yet."""
451
symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
452
% 'needs_format_conversion(format=None)')
455
def clone(self, url, revision_id=None, force_new_repo=False,
456
preserve_stacking=False):
458
return self._real_bzrdir.clone(url, revision_id=revision_id,
459
force_new_repo=force_new_repo, preserve_stacking=preserve_stacking)
461
def _get_config(self):
462
return RemoteBzrDirConfig(self)
465
class RemoteRepositoryFormat(repository.RepositoryFormat):
466
"""Format for repositories accessed over a _SmartClient.
468
Instances of this repository are represented by RemoteRepository
471
The RemoteRepositoryFormat is parameterized during construction
472
to reflect the capabilities of the real, remote format. Specifically
473
the attributes rich_root_data and supports_tree_reference are set
474
on a per instance basis, and are not set (and should not be) at
477
:ivar _custom_format: If set, a specific concrete repository format that
478
will be used when initializing a repository with this
479
RemoteRepositoryFormat.
480
:ivar _creating_repo: If set, the repository object that this
481
RemoteRepositoryFormat was created for: it can be called into
482
to obtain data like the network name.
485
_matchingbzrdir = RemoteBzrDirFormat()
488
repository.RepositoryFormat.__init__(self)
489
self._custom_format = None
490
self._network_name = None
491
self._creating_bzrdir = None
492
self._supports_chks = None
493
self._supports_external_lookups = None
494
self._supports_tree_reference = None
495
self._rich_root_data = None
498
return "%s(_network_name=%r)" % (self.__class__.__name__,
502
def fast_deltas(self):
504
return self._custom_format.fast_deltas
507
def rich_root_data(self):
508
if self._rich_root_data is None:
510
self._rich_root_data = self._custom_format.rich_root_data
511
return self._rich_root_data
514
def supports_chks(self):
515
if self._supports_chks is None:
517
self._supports_chks = self._custom_format.supports_chks
518
return self._supports_chks
521
def supports_external_lookups(self):
522
if self._supports_external_lookups is None:
524
self._supports_external_lookups = \
525
self._custom_format.supports_external_lookups
526
return self._supports_external_lookups
529
def supports_tree_reference(self):
530
if self._supports_tree_reference is None:
532
self._supports_tree_reference = \
533
self._custom_format.supports_tree_reference
534
return self._supports_tree_reference
536
def _vfs_initialize(self, a_bzrdir, shared):
537
"""Helper for common code in initialize."""
538
if self._custom_format:
539
# Custom format requested
540
result = self._custom_format.initialize(a_bzrdir, shared=shared)
541
elif self._creating_bzrdir is not None:
542
# Use the format that the repository we were created to back
544
prior_repo = self._creating_bzrdir.open_repository()
545
prior_repo._ensure_real()
546
result = prior_repo._real_repository._format.initialize(
547
a_bzrdir, shared=shared)
549
# assume that a_bzr is a RemoteBzrDir but the smart server didn't
550
# support remote initialization.
551
# We delegate to a real object at this point (as RemoteBzrDir
552
# delegate to the repository format which would lead to infinite
553
# recursion if we just called a_bzrdir.create_repository.
554
a_bzrdir._ensure_real()
555
result = a_bzrdir._real_bzrdir.create_repository(shared=shared)
556
if not isinstance(result, RemoteRepository):
557
return self.open(a_bzrdir)
561
def initialize(self, a_bzrdir, shared=False):
562
# Being asked to create on a non RemoteBzrDir:
563
if not isinstance(a_bzrdir, RemoteBzrDir):
564
return self._vfs_initialize(a_bzrdir, shared)
565
medium = a_bzrdir._client._medium
566
if medium._is_remote_before((1, 13)):
567
return self._vfs_initialize(a_bzrdir, shared)
568
# Creating on a remote bzr dir.
569
# 1) get the network name to use.
570
if self._custom_format:
571
network_name = self._custom_format.network_name()
572
elif self._network_name:
573
network_name = self._network_name
575
# Select the current bzrlib default and ask for that.
576
reference_bzrdir_format = bzrdir.format_registry.get('default')()
577
reference_format = reference_bzrdir_format.repository_format
578
network_name = reference_format.network_name()
579
# 2) try direct creation via RPC
580
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
581
verb = 'BzrDir.create_repository'
587
response = a_bzrdir._call(verb, path, network_name, shared_str)
588
except errors.UnknownSmartMethod:
589
# Fallback - use vfs methods
590
medium._remember_remote_is_before((1, 13))
591
return self._vfs_initialize(a_bzrdir, shared)
593
# Turn the response into a RemoteRepository object.
594
format = response_tuple_to_repo_format(response[1:])
595
# Used to support creating a real format instance when needed.
596
format._creating_bzrdir = a_bzrdir
597
remote_repo = RemoteRepository(a_bzrdir, format)
598
format._creating_repo = remote_repo
601
def open(self, a_bzrdir):
602
if not isinstance(a_bzrdir, RemoteBzrDir):
603
raise AssertionError('%r is not a RemoteBzrDir' % (a_bzrdir,))
604
return a_bzrdir.open_repository()
606
def _ensure_real(self):
607
if self._custom_format is None:
608
self._custom_format = repository.network_format_registry.get(
612
def _fetch_order(self):
614
return self._custom_format._fetch_order
617
def _fetch_uses_deltas(self):
619
return self._custom_format._fetch_uses_deltas
622
def _fetch_reconcile(self):
624
return self._custom_format._fetch_reconcile
626
def get_format_description(self):
628
return 'Remote: ' + self._custom_format.get_format_description()
630
def __eq__(self, other):
631
return self.__class__ is other.__class__
633
def network_name(self):
634
if self._network_name:
635
return self._network_name
636
self._creating_repo._ensure_real()
637
return self._creating_repo._real_repository._format.network_name()
640
def pack_compresses(self):
642
return self._custom_format.pack_compresses
645
def _serializer(self):
647
return self._custom_format._serializer
650
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
651
bzrdir.ControlComponent):
652
"""Repository accessed over rpc.
654
For the moment most operations are performed using local transport-backed
658
def __init__(self, remote_bzrdir, format, real_repository=None, _client=None):
659
"""Create a RemoteRepository instance.
661
:param remote_bzrdir: The bzrdir hosting this repository.
662
:param format: The RemoteFormat object to use.
663
:param real_repository: If not None, a local implementation of the
664
repository logic for the repository, usually accessing the data
666
:param _client: Private testing parameter - override the smart client
667
to be used by the repository.
670
self._real_repository = real_repository
672
self._real_repository = None
673
self.bzrdir = remote_bzrdir
675
self._client = remote_bzrdir._client
677
self._client = _client
678
self._format = format
679
self._lock_mode = None
680
self._lock_token = None
682
self._leave_lock = False
683
# Cache of revision parents; misses are cached during read locks, and
684
# write locks when no _real_repository has been set.
685
self._unstacked_provider = graph.CachingParentsProvider(
686
get_parent_map=self._get_parent_map_rpc)
687
self._unstacked_provider.disable_cache()
689
# These depend on the actual remote format, so force them off for
690
# maximum compatibility. XXX: In future these should depend on the
691
# remote repository instance, but this is irrelevant until we perform
692
# reconcile via an RPC call.
693
self._reconcile_does_inventory_gc = False
694
self._reconcile_fixes_text_parents = False
695
self._reconcile_backsup_inventory = False
696
self.base = self.bzrdir.transport.base
697
# Additional places to query for data.
698
self._fallback_repositories = []
701
def user_transport(self):
702
return self.bzrdir.user_transport
705
def control_transport(self):
706
# XXX: Normally you shouldn't directly get at the remote repository
707
# transport, but I'm not sure it's worth making this method
708
# optional -- mbp 2010-04-21
709
return self.bzrdir.get_repository_transport(None)
712
return "%s(%s)" % (self.__class__.__name__, self.base)
716
def abort_write_group(self, suppress_errors=False):
717
"""Complete a write group on the decorated repository.
719
Smart methods perform operations in a single step so this API
720
is not really applicable except as a compatibility thunk
721
for older plugins that don't use e.g. the CommitBuilder
724
:param suppress_errors: see Repository.abort_write_group.
727
return self._real_repository.abort_write_group(
728
suppress_errors=suppress_errors)
732
"""Decorate the real repository for now.
734
In the long term a full blown network facility is needed to avoid
735
creating a real repository object locally.
738
return self._real_repository.chk_bytes
740
def commit_write_group(self):
741
"""Complete a write group on the decorated repository.
743
Smart methods perform operations in a single step so this API
744
is not really applicable except as a compatibility thunk
745
for older plugins that don't use e.g. the CommitBuilder
749
return self._real_repository.commit_write_group()
751
def resume_write_group(self, tokens):
753
return self._real_repository.resume_write_group(tokens)
755
def suspend_write_group(self):
757
return self._real_repository.suspend_write_group()
759
def get_missing_parent_inventories(self, check_for_missing_texts=True):
761
return self._real_repository.get_missing_parent_inventories(
762
check_for_missing_texts=check_for_missing_texts)
764
def _get_rev_id_for_revno_vfs(self, revno, known_pair):
766
return self._real_repository.get_rev_id_for_revno(
769
def get_rev_id_for_revno(self, revno, known_pair):
770
"""See Repository.get_rev_id_for_revno."""
771
path = self.bzrdir._path_for_remote_call(self._client)
773
if self._client._medium._is_remote_before((1, 17)):
774
return self._get_rev_id_for_revno_vfs(revno, known_pair)
775
response = self._call(
776
'Repository.get_rev_id_for_revno', path, revno, known_pair)
777
except errors.UnknownSmartMethod:
778
self._client._medium._remember_remote_is_before((1, 17))
779
return self._get_rev_id_for_revno_vfs(revno, known_pair)
780
if response[0] == 'ok':
781
return True, response[1]
782
elif response[0] == 'history-incomplete':
783
known_pair = response[1:3]
784
for fallback in self._fallback_repositories:
785
found, result = fallback.get_rev_id_for_revno(revno, known_pair)
790
# Not found in any fallbacks
791
return False, known_pair
793
raise errors.UnexpectedSmartServerResponse(response)
795
def _ensure_real(self):
796
"""Ensure that there is a _real_repository set.
798
Used before calls to self._real_repository.
800
Note that _ensure_real causes many roundtrips to the server which are
801
not desirable, and prevents the use of smart one-roundtrip RPC's to
802
perform complex operations (such as accessing parent data, streaming
803
revisions etc). Adding calls to _ensure_real should only be done when
804
bringing up new functionality, adding fallbacks for smart methods that
805
require a fallback path, and never to replace an existing smart method
806
invocation. If in doubt chat to the bzr network team.
808
if self._real_repository is None:
809
if 'hpssvfs' in debug.debug_flags:
811
warning('VFS Repository access triggered\n%s',
812
''.join(traceback.format_stack()))
813
self._unstacked_provider.missing_keys.clear()
814
self.bzrdir._ensure_real()
815
self._set_real_repository(
816
self.bzrdir._real_bzrdir.open_repository())
818
def _translate_error(self, err, **context):
819
self.bzrdir._translate_error(err, repository=self, **context)
821
def find_text_key_references(self):
822
"""Find the text key references within the repository.
824
:return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
825
revision_ids. Each altered file-ids has the exact revision_ids that
826
altered it listed explicitly.
827
:return: A dictionary mapping text keys ((fileid, revision_id) tuples)
828
to whether they were referred to by the inventory of the
829
revision_id that they contain. The inventory texts from all present
830
revision ids are assessed to generate this report.
833
return self._real_repository.find_text_key_references()
835
def _generate_text_key_index(self):
836
"""Generate a new text key index for the repository.
838
This is an expensive function that will take considerable time to run.
840
:return: A dict mapping (file_id, revision_id) tuples to a list of
841
parents, also (file_id, revision_id) tuples.
844
return self._real_repository._generate_text_key_index()
846
def _get_revision_graph(self, revision_id):
847
"""Private method for using with old (< 1.2) servers to fallback."""
848
if revision_id is None:
850
elif revision.is_null(revision_id):
853
path = self.bzrdir._path_for_remote_call(self._client)
854
response = self._call_expecting_body(
855
'Repository.get_revision_graph', path, revision_id)
856
response_tuple, response_handler = response
857
if response_tuple[0] != 'ok':
858
raise errors.UnexpectedSmartServerResponse(response_tuple)
859
coded = response_handler.read_body_bytes()
861
# no revisions in this repository!
863
lines = coded.split('\n')
866
d = tuple(line.split())
867
revision_graph[d[0]] = d[1:]
869
return revision_graph
872
"""See Repository._get_sink()."""
873
return RemoteStreamSink(self)
875
def _get_source(self, to_format):
876
"""Return a source for streaming from this repository."""
877
return RemoteStreamSource(self, to_format)
880
def has_revision(self, revision_id):
881
"""True if this repository has a copy of the revision."""
882
# Copy of bzrlib.repository.Repository.has_revision
883
return revision_id in self.has_revisions((revision_id,))
886
def has_revisions(self, revision_ids):
887
"""Probe to find out the presence of multiple revisions.
889
:param revision_ids: An iterable of revision_ids.
890
:return: A set of the revision_ids that were present.
892
# Copy of bzrlib.repository.Repository.has_revisions
893
parent_map = self.get_parent_map(revision_ids)
894
result = set(parent_map)
895
if _mod_revision.NULL_REVISION in revision_ids:
896
result.add(_mod_revision.NULL_REVISION)
899
def _has_same_fallbacks(self, other_repo):
900
"""Returns true if the repositories have the same fallbacks."""
901
# XXX: copied from Repository; it should be unified into a base class
902
# <https://bugs.edge.launchpad.net/bzr/+bug/401622>
903
my_fb = self._fallback_repositories
904
other_fb = other_repo._fallback_repositories
905
if len(my_fb) != len(other_fb):
907
for f, g in zip(my_fb, other_fb):
908
if not f.has_same_location(g):
912
def has_same_location(self, other):
913
# TODO: Move to RepositoryBase and unify with the regular Repository
914
# one; unfortunately the tests rely on slightly different behaviour at
915
# present -- mbp 20090710
916
return (self.__class__ is other.__class__ and
917
self.bzrdir.transport.base == other.bzrdir.transport.base)
919
def get_graph(self, other_repository=None):
920
"""Return the graph for this repository format"""
921
parents_provider = self._make_parents_provider(other_repository)
922
return graph.Graph(parents_provider)
925
def get_known_graph_ancestry(self, revision_ids):
926
"""Return the known graph for a set of revision ids and their ancestors.
928
st = static_tuple.StaticTuple
929
revision_keys = [st(r_id).intern() for r_id in revision_ids]
930
known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
931
return graph.GraphThunkIdsToKeys(known_graph)
933
def gather_stats(self, revid=None, committers=None):
934
"""See Repository.gather_stats()."""
935
path = self.bzrdir._path_for_remote_call(self._client)
936
# revid can be None to indicate no revisions, not just NULL_REVISION
937
if revid is None or revision.is_null(revid):
941
if committers is None or not committers:
942
fmt_committers = 'no'
944
fmt_committers = 'yes'
945
response_tuple, response_handler = self._call_expecting_body(
946
'Repository.gather_stats', path, fmt_revid, fmt_committers)
947
if response_tuple[0] != 'ok':
948
raise errors.UnexpectedSmartServerResponse(response_tuple)
950
body = response_handler.read_body_bytes()
952
for line in body.split('\n'):
955
key, val_text = line.split(':')
956
if key in ('revisions', 'size', 'committers'):
957
result[key] = int(val_text)
958
elif key in ('firstrev', 'latestrev'):
959
values = val_text.split(' ')[1:]
960
result[key] = (float(values[0]), long(values[1]))
964
def find_branches(self, using=False):
965
"""See Repository.find_branches()."""
966
# should be an API call to the server.
968
return self._real_repository.find_branches(using=using)
970
def get_physical_lock_status(self):
971
"""See Repository.get_physical_lock_status()."""
972
# should be an API call to the server.
974
return self._real_repository.get_physical_lock_status()
976
def is_in_write_group(self):
977
"""Return True if there is an open write group.
979
write groups are only applicable locally for the smart server..
981
if self._real_repository:
982
return self._real_repository.is_in_write_group()
985
return self._lock_count >= 1
988
"""See Repository.is_shared()."""
989
path = self.bzrdir._path_for_remote_call(self._client)
990
response = self._call('Repository.is_shared', path)
991
if response[0] not in ('yes', 'no'):
992
raise SmartProtocolError('unexpected response code %s' % (response,))
993
return response[0] == 'yes'
995
def is_write_locked(self):
996
return self._lock_mode == 'w'
998
def _warn_if_deprecated(self, branch=None):
999
# If we have a real repository, the check will be done there, if we
1000
# don't the check will be done remotely.
1003
def lock_read(self):
1004
"""Lock the repository for read operations.
1006
:return: A bzrlib.lock.LogicalLockResult.
1008
# wrong eventually - want a local lock cache context
1009
if not self._lock_mode:
1010
self._note_lock('r')
1011
self._lock_mode = 'r'
1012
self._lock_count = 1
1013
self._unstacked_provider.enable_cache(cache_misses=True)
1014
if self._real_repository is not None:
1015
self._real_repository.lock_read()
1016
for repo in self._fallback_repositories:
1019
self._lock_count += 1
1020
return lock.LogicalLockResult(self.unlock)
1022
def _remote_lock_write(self, token):
1023
path = self.bzrdir._path_for_remote_call(self._client)
1026
err_context = {'token': token}
1027
response = self._call('Repository.lock_write', path, token,
1029
if response[0] == 'ok':
1030
ok, token = response
1033
raise errors.UnexpectedSmartServerResponse(response)
1035
def lock_write(self, token=None, _skip_rpc=False):
1036
if not self._lock_mode:
1037
self._note_lock('w')
1039
if self._lock_token is not None:
1040
if token != self._lock_token:
1041
raise errors.TokenMismatch(token, self._lock_token)
1042
self._lock_token = token
1044
self._lock_token = self._remote_lock_write(token)
1045
# if self._lock_token is None, then this is something like packs or
1046
# svn where we don't get to lock the repo, or a weave style repository
1047
# where we cannot lock it over the wire and attempts to do so will
1049
if self._real_repository is not None:
1050
self._real_repository.lock_write(token=self._lock_token)
1051
if token is not None:
1052
self._leave_lock = True
1054
self._leave_lock = False
1055
self._lock_mode = 'w'
1056
self._lock_count = 1
1057
cache_misses = self._real_repository is None
1058
self._unstacked_provider.enable_cache(cache_misses=cache_misses)
1059
for repo in self._fallback_repositories:
1060
# Writes don't affect fallback repos
1062
elif self._lock_mode == 'r':
1063
raise errors.ReadOnlyError(self)
1065
self._lock_count += 1
1066
return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
1068
def leave_lock_in_place(self):
1069
if not self._lock_token:
1070
raise NotImplementedError(self.leave_lock_in_place)
1071
self._leave_lock = True
1073
def dont_leave_lock_in_place(self):
1074
if not self._lock_token:
1075
raise NotImplementedError(self.dont_leave_lock_in_place)
1076
self._leave_lock = False
1078
def _set_real_repository(self, repository):
1079
"""Set the _real_repository for this repository.
1081
:param repository: The repository to fallback to for non-hpss
1082
implemented operations.
1084
if self._real_repository is not None:
1085
# Replacing an already set real repository.
1086
# We cannot do this [currently] if the repository is locked -
1087
# synchronised state might be lost.
1088
if self.is_locked():
1089
raise AssertionError('_real_repository is already set')
1090
if isinstance(repository, RemoteRepository):
1091
raise AssertionError()
1092
self._real_repository = repository
1093
# three code paths happen here:
1094
# 1) old servers, RemoteBranch.open() calls _ensure_real before setting
1095
# up stacking. In this case self._fallback_repositories is [], and the
1096
# real repo is already setup. Preserve the real repo and
1097
# RemoteRepository.add_fallback_repository will avoid adding
1099
# 2) new servers, RemoteBranch.open() sets up stacking, and when
1100
# ensure_real is triggered from a branch, the real repository to
1101
# set already has a matching list with separate instances, but
1102
# as they are also RemoteRepositories we don't worry about making the
1103
# lists be identical.
1104
# 3) new servers, RemoteRepository.ensure_real is triggered before
1105
# RemoteBranch.ensure real, in this case we get a repo with no fallbacks
1106
# and need to populate it.
1107
if (self._fallback_repositories and
1108
len(self._real_repository._fallback_repositories) !=
1109
len(self._fallback_repositories)):
1110
if len(self._real_repository._fallback_repositories):
1111
raise AssertionError(
1112
"cannot cleanly remove existing _fallback_repositories")
1113
for fb in self._fallback_repositories:
1114
self._real_repository.add_fallback_repository(fb)
1115
if self._lock_mode == 'w':
1116
# if we are already locked, the real repository must be able to
1117
# acquire the lock with our token.
1118
self._real_repository.lock_write(self._lock_token)
1119
elif self._lock_mode == 'r':
1120
self._real_repository.lock_read()
1122
def start_write_group(self):
1123
"""Start a write group on the decorated repository.
1125
Smart methods perform operations in a single step so this API
1126
is not really applicable except as a compatibility thunk
1127
for older plugins that don't use e.g. the CommitBuilder
1131
return self._real_repository.start_write_group()
1133
def _unlock(self, token):
1134
path = self.bzrdir._path_for_remote_call(self._client)
1136
# with no token the remote repository is not persistently locked.
1138
err_context = {'token': token}
1139
response = self._call('Repository.unlock', path, token,
1141
if response == ('ok',):
1144
raise errors.UnexpectedSmartServerResponse(response)
1146
@only_raises(errors.LockNotHeld, errors.LockBroken)
1148
if not self._lock_count:
1149
return lock.cant_unlock_not_held(self)
1150
self._lock_count -= 1
1151
if self._lock_count > 0:
1153
self._unstacked_provider.disable_cache()
1154
old_mode = self._lock_mode
1155
self._lock_mode = None
1157
# The real repository is responsible at present for raising an
1158
# exception if it's in an unfinished write group. However, it
1159
# normally will *not* actually remove the lock from disk - that's
1160
# done by the server on receiving the Repository.unlock call.
1161
# This is just to let the _real_repository stay up to date.
1162
if self._real_repository is not None:
1163
self._real_repository.unlock()
1165
# The rpc-level lock should be released even if there was a
1166
# problem releasing the vfs-based lock.
1168
# Only write-locked repositories need to make a remote method
1169
# call to perform the unlock.
1170
old_token = self._lock_token
1171
self._lock_token = None
1172
if not self._leave_lock:
1173
self._unlock(old_token)
1174
# Fallbacks are always 'lock_read()' so we don't pay attention to
1176
for repo in self._fallback_repositories:
1179
def break_lock(self):
1180
# should hand off to the network
1182
return self._real_repository.break_lock()
1184
def _get_tarball(self, compression):
1185
"""Return a TemporaryFile containing a repository tarball.
1187
Returns None if the server does not support sending tarballs.
1190
path = self.bzrdir._path_for_remote_call(self._client)
1192
response, protocol = self._call_expecting_body(
1193
'Repository.tarball', path, compression)
1194
except errors.UnknownSmartMethod:
1195
protocol.cancel_read_body()
1197
if response[0] == 'ok':
1198
# Extract the tarball and return it
1199
t = tempfile.NamedTemporaryFile()
1200
# TODO: rpc layer should read directly into it...
1201
t.write(protocol.read_body_bytes())
1204
raise errors.UnexpectedSmartServerResponse(response)
1206
def sprout(self, to_bzrdir, revision_id=None):
1207
# TODO: Option to control what format is created?
1209
dest_repo = self._real_repository._format.initialize(to_bzrdir,
1211
dest_repo.fetch(self, revision_id=revision_id)
1214
### These methods are just thin shims to the VFS object for now.
1216
def revision_tree(self, revision_id):
1218
return self._real_repository.revision_tree(revision_id)
1220
def get_serializer_format(self):
1222
return self._real_repository.get_serializer_format()
1224
def get_commit_builder(self, branch, parents, config, timestamp=None,
1225
timezone=None, committer=None, revprops=None,
1227
# FIXME: It ought to be possible to call this without immediately
1228
# triggering _ensure_real. For now it's the easiest thing to do.
1230
real_repo = self._real_repository
1231
builder = real_repo.get_commit_builder(branch, parents,
1232
config, timestamp=timestamp, timezone=timezone,
1233
committer=committer, revprops=revprops, revision_id=revision_id)
1236
def add_fallback_repository(self, repository):
1237
"""Add a repository to use for looking up data not held locally.
1239
:param repository: A repository.
1241
if not self._format.supports_external_lookups:
1242
raise errors.UnstackableRepositoryFormat(
1243
self._format.network_name(), self.base)
1244
# We need to accumulate additional repositories here, to pass them in
1247
if self.is_locked():
1248
# We will call fallback.unlock() when we transition to the unlocked
1249
# state, so always add a lock here. If a caller passes us a locked
1250
# repository, they are responsible for unlocking it later.
1251
repository.lock_read()
1252
self._check_fallback_repository(repository)
1253
self._fallback_repositories.append(repository)
1254
# If self._real_repository was parameterised already (e.g. because a
1255
# _real_branch had its get_stacked_on_url method called), then the
1256
# repository to be added may already be in the _real_repositories list.
1257
if self._real_repository is not None:
1258
fallback_locations = [repo.user_url for repo in
1259
self._real_repository._fallback_repositories]
1260
if repository.user_url not in fallback_locations:
1261
self._real_repository.add_fallback_repository(repository)
1263
def _check_fallback_repository(self, repository):
1264
"""Check that this repository can fallback to repository safely.
1266
Raise an error if not.
1268
:param repository: A repository to fallback to.
1270
return _mod_repository.InterRepository._assert_same_model(
1273
def add_inventory(self, revid, inv, parents):
1275
return self._real_repository.add_inventory(revid, inv, parents)
1277
def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1278
parents, basis_inv=None, propagate_caches=False):
1280
return self._real_repository.add_inventory_by_delta(basis_revision_id,
1281
delta, new_revision_id, parents, basis_inv=basis_inv,
1282
propagate_caches=propagate_caches)
1284
def add_revision(self, rev_id, rev, inv=None, config=None):
1286
return self._real_repository.add_revision(
1287
rev_id, rev, inv=inv, config=config)
1290
def get_inventory(self, revision_id):
1292
return self._real_repository.get_inventory(revision_id)
1294
def iter_inventories(self, revision_ids, ordering=None):
1296
return self._real_repository.iter_inventories(revision_ids, ordering)
1299
def get_revision(self, revision_id):
1301
return self._real_repository.get_revision(revision_id)
1303
def get_transaction(self):
1305
return self._real_repository.get_transaction()
1308
def clone(self, a_bzrdir, revision_id=None):
1310
return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
1312
def make_working_trees(self):
1313
"""See Repository.make_working_trees"""
1315
return self._real_repository.make_working_trees()
1317
def refresh_data(self):
1318
"""Re-read any data needed to synchronise with disk.
1320
This method is intended to be called after another repository instance
1321
(such as one used by a smart server) has inserted data into the
1322
repository. On all repositories this will work outside of write groups.
1323
Some repository formats (pack and newer for bzrlib native formats)
1324
support refresh_data inside write groups. If called inside a write
1325
group on a repository that does not support refreshing in a write group
1326
IsInWriteGroupError will be raised.
1328
if self._real_repository is not None:
1329
self._real_repository.refresh_data()
1331
def revision_ids_to_search_result(self, result_set):
1332
"""Convert a set of revision ids to a graph SearchResult."""
1333
result_parents = set()
1334
for parents in self.get_graph().get_parent_map(
1335
result_set).itervalues():
1336
result_parents.update(parents)
1337
included_keys = result_set.intersection(result_parents)
1338
start_keys = result_set.difference(included_keys)
1339
exclude_keys = result_parents.difference(result_set)
1340
result = graph.SearchResult(start_keys, exclude_keys,
1341
len(result_set), result_set)
1345
def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1346
"""Return the revision ids that other has that this does not.
1348
These are returned in topological order.
1350
revision_id: only return revision ids included by revision_id.
1352
return repository.InterRepository.get(
1353
other, self).search_missing_revision_ids(revision_id, find_ghosts)
1355
def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
1357
# No base implementation to use as RemoteRepository is not a subclass
1358
# of Repository; so this is a copy of Repository.fetch().
1359
if fetch_spec is not None and revision_id is not None:
1360
raise AssertionError(
1361
"fetch_spec and revision_id are mutually exclusive.")
1362
if self.is_in_write_group():
1363
raise errors.InternalBzrError(
1364
"May not fetch while in a write group.")
1365
# fast path same-url fetch operations
1366
if (self.has_same_location(source)
1367
and fetch_spec is None
1368
and self._has_same_fallbacks(source)):
1369
# check that last_revision is in 'from' and then return a
1371
if (revision_id is not None and
1372
not revision.is_null(revision_id)):
1373
self.get_revision(revision_id)
1375
# if there is no specific appropriate InterRepository, this will get
1376
# the InterRepository base class, which raises an
1377
# IncompatibleRepositories when asked to fetch.
1378
inter = repository.InterRepository.get(source, self)
1379
return inter.fetch(revision_id=revision_id, pb=pb,
1380
find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1382
def create_bundle(self, target, base, fileobj, format=None):
1384
self._real_repository.create_bundle(target, base, fileobj, format)
1387
def get_ancestry(self, revision_id, topo_sorted=True):
1389
return self._real_repository.get_ancestry(revision_id, topo_sorted)
1391
def fileids_altered_by_revision_ids(self, revision_ids):
1393
return self._real_repository.fileids_altered_by_revision_ids(revision_ids)
1395
def _get_versioned_file_checker(self, revisions, revision_versions_cache):
1397
return self._real_repository._get_versioned_file_checker(
1398
revisions, revision_versions_cache)
1400
def iter_files_bytes(self, desired_files):
1401
"""See Repository.iter_file_bytes.
1404
return self._real_repository.iter_files_bytes(desired_files)
1406
def get_parent_map(self, revision_ids):
1407
"""See bzrlib.Graph.get_parent_map()."""
1408
return self._make_parents_provider().get_parent_map(revision_ids)
1410
def _get_parent_map_rpc(self, keys):
1411
"""Helper for get_parent_map that performs the RPC."""
1412
medium = self._client._medium
1413
if medium._is_remote_before((1, 2)):
1414
# We already found out that the server can't understand
1415
# Repository.get_parent_map requests, so just fetch the whole
1418
# Note that this reads the whole graph, when only some keys are
1419
# wanted. On this old server there's no way (?) to get them all
1420
# in one go, and the user probably will have seen a warning about
1421
# the server being old anyhow.
1422
rg = self._get_revision_graph(None)
1423
# There is an API discrepancy between get_parent_map and
1424
# get_revision_graph. Specifically, a "key:()" pair in
1425
# get_revision_graph just means a node has no parents. For
1426
# "get_parent_map" it means the node is a ghost. So fix up the
1427
# graph to correct this.
1428
# https://bugs.launchpad.net/bzr/+bug/214894
1429
# There is one other "bug" which is that ghosts in
1430
# get_revision_graph() are not returned at all. But we won't worry
1431
# about that for now.
1432
for node_id, parent_ids in rg.iteritems():
1433
if parent_ids == ():
1434
rg[node_id] = (NULL_REVISION,)
1435
rg[NULL_REVISION] = ()
1440
raise ValueError('get_parent_map(None) is not valid')
1441
if NULL_REVISION in keys:
1442
keys.discard(NULL_REVISION)
1443
found_parents = {NULL_REVISION:()}
1445
return found_parents
1448
# TODO(Needs analysis): We could assume that the keys being requested
1449
# from get_parent_map are in a breadth first search, so typically they
1450
# will all be depth N from some common parent, and we don't have to
1451
# have the server iterate from the root parent, but rather from the
1452
# keys we're searching; and just tell the server the keyspace we
1453
# already have; but this may be more traffic again.
1455
# Transform self._parents_map into a search request recipe.
1456
# TODO: Manage this incrementally to avoid covering the same path
1457
# repeatedly. (The server will have to on each request, but the less
1458
# work done the better).
1460
# Negative caching notes:
1461
# new server sends missing when a request including the revid
1462
# 'include-missing:' is present in the request.
1463
# missing keys are serialised as missing:X, and we then call
1464
# provider.note_missing(X) for-all X
1465
parents_map = self._unstacked_provider.get_cached_map()
1466
if parents_map is None:
1467
# Repository is not locked, so there's no cache.
1469
# start_set is all the keys in the cache
1470
start_set = set(parents_map)
1471
# result set is all the references to keys in the cache
1472
result_parents = set()
1473
for parents in parents_map.itervalues():
1474
result_parents.update(parents)
1475
stop_keys = result_parents.difference(start_set)
1476
# We don't need to send ghosts back to the server as a position to
1478
stop_keys.difference_update(self._unstacked_provider.missing_keys)
1479
key_count = len(parents_map)
1480
if (NULL_REVISION in result_parents
1481
and NULL_REVISION in self._unstacked_provider.missing_keys):
1482
# If we pruned NULL_REVISION from the stop_keys because it's also
1483
# in our cache of "missing" keys we need to increment our key count
1484
# by 1, because the reconsitituted SearchResult on the server will
1485
# still consider NULL_REVISION to be an included key.
1487
included_keys = start_set.intersection(result_parents)
1488
start_set.difference_update(included_keys)
1489
recipe = ('manual', start_set, stop_keys, key_count)
1490
body = self._serialise_search_recipe(recipe)
1491
path = self.bzrdir._path_for_remote_call(self._client)
1493
if type(key) is not str:
1495
"key %r not a plain string" % (key,))
1496
verb = 'Repository.get_parent_map'
1497
args = (path, 'include-missing:') + tuple(keys)
1499
response = self._call_with_body_bytes_expecting_body(
1501
except errors.UnknownSmartMethod:
1502
# Server does not support this method, so get the whole graph.
1503
# Worse, we have to force a disconnection, because the server now
1504
# doesn't realise it has a body on the wire to consume, so the
1505
# only way to recover is to abandon the connection.
1507
'Server is too old for fast get_parent_map, reconnecting. '
1508
'(Upgrade the server to Bazaar 1.2 to avoid this)')
1510
# To avoid having to disconnect repeatedly, we keep track of the
1511
# fact the server doesn't understand remote methods added in 1.2.
1512
medium._remember_remote_is_before((1, 2))
1513
# Recurse just once and we should use the fallback code.
1514
return self._get_parent_map_rpc(keys)
1515
response_tuple, response_handler = response
1516
if response_tuple[0] not in ['ok']:
1517
response_handler.cancel_read_body()
1518
raise errors.UnexpectedSmartServerResponse(response_tuple)
1519
if response_tuple[0] == 'ok':
1520
coded = bz2.decompress(response_handler.read_body_bytes())
1522
# no revisions found
1524
lines = coded.split('\n')
1527
d = tuple(line.split())
1529
revision_graph[d[0]] = d[1:]
1532
if d[0].startswith('missing:'):
1534
self._unstacked_provider.note_missing_key(revid)
1536
# no parents - so give the Graph result
1538
revision_graph[d[0]] = (NULL_REVISION,)
1539
return revision_graph
1542
def get_signature_text(self, revision_id):
1544
return self._real_repository.get_signature_text(revision_id)
1547
def _get_inventory_xml(self, revision_id):
1549
return self._real_repository._get_inventory_xml(revision_id)
1551
def reconcile(self, other=None, thorough=False):
1553
return self._real_repository.reconcile(other=other, thorough=thorough)
1555
def all_revision_ids(self):
1557
return self._real_repository.all_revision_ids()
1560
def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1562
return self._real_repository.get_deltas_for_revisions(revisions,
1563
specific_fileids=specific_fileids)
1566
def get_revision_delta(self, revision_id, specific_fileids=None):
1568
return self._real_repository.get_revision_delta(revision_id,
1569
specific_fileids=specific_fileids)
1572
def revision_trees(self, revision_ids):
1574
return self._real_repository.revision_trees(revision_ids)
1577
def get_revision_reconcile(self, revision_id):
1579
return self._real_repository.get_revision_reconcile(revision_id)
1582
def check(self, revision_ids=None, callback_refs=None, check_repo=True):
1584
return self._real_repository.check(revision_ids=revision_ids,
1585
callback_refs=callback_refs, check_repo=check_repo)
1587
def copy_content_into(self, destination, revision_id=None):
1589
return self._real_repository.copy_content_into(
1590
destination, revision_id=revision_id)
1592
def _copy_repository_tarball(self, to_bzrdir, revision_id=None):
1593
# get a tarball of the remote repository, and copy from that into the
1595
from bzrlib import osutils
1597
# TODO: Maybe a progress bar while streaming the tarball?
1598
note("Copying repository content as tarball...")
1599
tar_file = self._get_tarball('bz2')
1600
if tar_file is None:
1602
destination = to_bzrdir.create_repository()
1604
tar = tarfile.open('repository', fileobj=tar_file,
1606
tmpdir = osutils.mkdtemp()
1608
_extract_tar(tar, tmpdir)
1609
tmp_bzrdir = BzrDir.open(tmpdir)
1610
tmp_repo = tmp_bzrdir.open_repository()
1611
tmp_repo.copy_content_into(destination, revision_id)
1613
osutils.rmtree(tmpdir)
1617
# TODO: Suggestion from john: using external tar is much faster than
1618
# python's tarfile library, but it may not work on windows.
1621
def inventories(self):
1622
"""Decorate the real repository for now.
1624
In the long term a full blown network facility is needed to
1625
avoid creating a real repository object locally.
1628
return self._real_repository.inventories
1631
def pack(self, hint=None, clean_obsolete_packs=False):
1632
"""Compress the data within the repository.
1634
This is not currently implemented within the smart server.
1637
return self._real_repository.pack(hint=hint, clean_obsolete_packs=clean_obsolete_packs)
1640
def revisions(self):
1641
"""Decorate the real repository for now.
1643
In the short term this should become a real object to intercept graph
1646
In the long term a full blown network facility is needed.
1649
return self._real_repository.revisions
1651
def set_make_working_trees(self, new_value):
1653
new_value_str = "True"
1655
new_value_str = "False"
1656
path = self.bzrdir._path_for_remote_call(self._client)
1658
response = self._call(
1659
'Repository.set_make_working_trees', path, new_value_str)
1660
except errors.UnknownSmartMethod:
1662
self._real_repository.set_make_working_trees(new_value)
1664
if response[0] != 'ok':
1665
raise errors.UnexpectedSmartServerResponse(response)
1668
def signatures(self):
1669
"""Decorate the real repository for now.
1671
In the long term a full blown network facility is needed to avoid
1672
creating a real repository object locally.
1675
return self._real_repository.signatures
1678
def sign_revision(self, revision_id, gpg_strategy):
1680
return self._real_repository.sign_revision(revision_id, gpg_strategy)
1684
"""Decorate the real repository for now.
1686
In the long term a full blown network facility is needed to avoid
1687
creating a real repository object locally.
1690
return self._real_repository.texts
1693
def get_revisions(self, revision_ids):
1695
return self._real_repository.get_revisions(revision_ids)
1697
def supports_rich_root(self):
1698
return self._format.rich_root_data
1700
def iter_reverse_revision_history(self, revision_id):
1702
return self._real_repository.iter_reverse_revision_history(revision_id)
1705
def _serializer(self):
1706
return self._format._serializer
1708
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1710
return self._real_repository.store_revision_signature(
1711
gpg_strategy, plaintext, revision_id)
1713
def add_signature_text(self, revision_id, signature):
1715
return self._real_repository.add_signature_text(revision_id, signature)
1717
def has_signature_for_revision_id(self, revision_id):
1719
return self._real_repository.has_signature_for_revision_id(revision_id)
1721
def item_keys_introduced_by(self, revision_ids, _files_pb=None):
1723
return self._real_repository.item_keys_introduced_by(revision_ids,
1724
_files_pb=_files_pb)
1726
def revision_graph_can_have_wrong_parents(self):
1727
# The answer depends on the remote repo format.
1729
return self._real_repository.revision_graph_can_have_wrong_parents()
1731
def _find_inconsistent_revision_parents(self, revisions_iterator=None):
1733
return self._real_repository._find_inconsistent_revision_parents(
1736
def _check_for_inconsistent_revision_parents(self):
1738
return self._real_repository._check_for_inconsistent_revision_parents()
1740
def _make_parents_provider(self, other=None):
1741
providers = [self._unstacked_provider]
1742
if other is not None:
1743
providers.insert(0, other)
1744
providers.extend(r._make_parents_provider() for r in
1745
self._fallback_repositories)
1746
return graph.StackedParentsProvider(providers)
1748
def _serialise_search_recipe(self, recipe):
1749
"""Serialise a graph search recipe.
1751
:param recipe: A search recipe (start, stop, count).
1752
:return: Serialised bytes.
1754
start_keys = ' '.join(recipe[1])
1755
stop_keys = ' '.join(recipe[2])
1756
count = str(recipe[3])
1757
return '\n'.join((start_keys, stop_keys, count))
1759
def _serialise_search_result(self, search_result):
1760
if isinstance(search_result, graph.PendingAncestryResult):
1761
parts = ['ancestry-of']
1762
parts.extend(search_result.heads)
1764
recipe = search_result.get_recipe()
1765
parts = [recipe[0], self._serialise_search_recipe(recipe)]
1766
return '\n'.join(parts)
1769
path = self.bzrdir._path_for_remote_call(self._client)
1771
response = self._call('PackRepository.autopack', path)
1772
except errors.UnknownSmartMethod:
1774
self._real_repository._pack_collection.autopack()
1777
if response[0] != 'ok':
1778
raise errors.UnexpectedSmartServerResponse(response)
1781
class RemoteStreamSink(repository.StreamSink):
1783
def _insert_real(self, stream, src_format, resume_tokens):
1784
self.target_repo._ensure_real()
1785
sink = self.target_repo._real_repository._get_sink()
1786
result = sink.insert_stream(stream, src_format, resume_tokens)
1788
self.target_repo.autopack()
1791
def insert_stream(self, stream, src_format, resume_tokens):
1792
target = self.target_repo
1793
target._unstacked_provider.missing_keys.clear()
1794
candidate_calls = [('Repository.insert_stream_1.19', (1, 19))]
1795
if target._lock_token:
1796
candidate_calls.append(('Repository.insert_stream_locked', (1, 14)))
1797
lock_args = (target._lock_token or '',)
1799
candidate_calls.append(('Repository.insert_stream', (1, 13)))
1801
client = target._client
1802
medium = client._medium
1803
path = target.bzrdir._path_for_remote_call(client)
1804
# Probe for the verb to use with an empty stream before sending the
1805
# real stream to it. We do this both to avoid the risk of sending a
1806
# large request that is then rejected, and because we don't want to
1807
# implement a way to buffer, rewind, or restart the stream.
1809
for verb, required_version in candidate_calls:
1810
if medium._is_remote_before(required_version):
1813
# We've already done the probing (and set _is_remote_before) on
1814
# a previous insert.
1817
byte_stream = smart_repo._stream_to_byte_stream([], src_format)
1819
response = client.call_with_body_stream(
1820
(verb, path, '') + lock_args, byte_stream)
1821
except errors.UnknownSmartMethod:
1822
medium._remember_remote_is_before(required_version)
1828
return self._insert_real(stream, src_format, resume_tokens)
1829
self._last_inv_record = None
1830
self._last_substream = None
1831
if required_version < (1, 19):
1832
# Remote side doesn't support inventory deltas. Wrap the stream to
1833
# make sure we don't send any. If the stream contains inventory
1834
# deltas we'll interrupt the smart insert_stream request and
1836
stream = self._stop_stream_if_inventory_delta(stream)
1837
byte_stream = smart_repo._stream_to_byte_stream(
1839
resume_tokens = ' '.join(resume_tokens)
1840
response = client.call_with_body_stream(
1841
(verb, path, resume_tokens) + lock_args, byte_stream)
1842
if response[0][0] not in ('ok', 'missing-basis'):
1843
raise errors.UnexpectedSmartServerResponse(response)
1844
if self._last_substream is not None:
1845
# The stream included an inventory-delta record, but the remote
1846
# side isn't new enough to support them. So we need to send the
1847
# rest of the stream via VFS.
1848
self.target_repo.refresh_data()
1849
return self._resume_stream_with_vfs(response, src_format)
1850
if response[0][0] == 'missing-basis':
1851
tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1852
resume_tokens = tokens
1853
return resume_tokens, set(missing_keys)
1855
self.target_repo.refresh_data()
1858
def _resume_stream_with_vfs(self, response, src_format):
1859
"""Resume sending a stream via VFS, first resending the record and
1860
substream that couldn't be sent via an insert_stream verb.
1862
if response[0][0] == 'missing-basis':
1863
tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1864
# Ignore missing_keys, we haven't finished inserting yet
1867
def resume_substream():
1868
# Yield the substream that was interrupted.
1869
for record in self._last_substream:
1871
self._last_substream = None
1872
def resume_stream():
1873
# Finish sending the interrupted substream
1874
yield ('inventory-deltas', resume_substream())
1875
# Then simply continue sending the rest of the stream.
1876
for substream_kind, substream in self._last_stream:
1877
yield substream_kind, substream
1878
return self._insert_real(resume_stream(), src_format, tokens)
1880
def _stop_stream_if_inventory_delta(self, stream):
1881
"""Normally this just lets the original stream pass-through unchanged.
1883
However if any 'inventory-deltas' substream occurs it will stop
1884
streaming, and store the interrupted substream and stream in
1885
self._last_substream and self._last_stream so that the stream can be
1886
resumed by _resume_stream_with_vfs.
1889
stream_iter = iter(stream)
1890
for substream_kind, substream in stream_iter:
1891
if substream_kind == 'inventory-deltas':
1892
self._last_substream = substream
1893
self._last_stream = stream_iter
1896
yield substream_kind, substream
1899
class RemoteStreamSource(repository.StreamSource):
1900
"""Stream data from a remote server."""
1902
def get_stream(self, search):
1903
if (self.from_repository._fallback_repositories and
1904
self.to_format._fetch_order == 'topological'):
1905
return self._real_stream(self.from_repository, search)
1908
repos = [self.from_repository]
1914
repos.extend(repo._fallback_repositories)
1915
sources.append(repo)
1916
return self.missing_parents_chain(search, sources)
1918
def get_stream_for_missing_keys(self, missing_keys):
1919
self.from_repository._ensure_real()
1920
real_repo = self.from_repository._real_repository
1921
real_source = real_repo._get_source(self.to_format)
1922
return real_source.get_stream_for_missing_keys(missing_keys)
1924
def _real_stream(self, repo, search):
1925
"""Get a stream for search from repo.
1927
This never called RemoteStreamSource.get_stream, and is a heler
1928
for RemoteStreamSource._get_stream to allow getting a stream
1929
reliably whether fallback back because of old servers or trying
1930
to stream from a non-RemoteRepository (which the stacked support
1933
source = repo._get_source(self.to_format)
1934
if isinstance(source, RemoteStreamSource):
1936
source = repo._real_repository._get_source(self.to_format)
1937
return source.get_stream(search)
1939
def _get_stream(self, repo, search):
1940
"""Core worker to get a stream from repo for search.
1942
This is used by both get_stream and the stacking support logic. It
1943
deliberately gets a stream for repo which does not need to be
1944
self.from_repository. In the event that repo is not Remote, or
1945
cannot do a smart stream, a fallback is made to the generic
1946
repository._get_stream() interface, via self._real_stream.
1948
In the event of stacking, streams from _get_stream will not
1949
contain all the data for search - this is normal (see get_stream).
1951
:param repo: A repository.
1952
:param search: A search.
1954
# Fallbacks may be non-smart
1955
if not isinstance(repo, RemoteRepository):
1956
return self._real_stream(repo, search)
1957
client = repo._client
1958
medium = client._medium
1959
path = repo.bzrdir._path_for_remote_call(client)
1960
search_bytes = repo._serialise_search_result(search)
1961
args = (path, self.to_format.network_name())
1963
('Repository.get_stream_1.19', (1, 19)),
1964
('Repository.get_stream', (1, 13))]
1966
for verb, version in candidate_verbs:
1967
if medium._is_remote_before(version):
1970
response = repo._call_with_body_bytes_expecting_body(
1971
verb, args, search_bytes)
1972
except errors.UnknownSmartMethod:
1973
medium._remember_remote_is_before(version)
1975
response_tuple, response_handler = response
1979
return self._real_stream(repo, search)
1980
if response_tuple[0] != 'ok':
1981
raise errors.UnexpectedSmartServerResponse(response_tuple)
1982
byte_stream = response_handler.read_streamed_body()
1983
src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
1984
if src_format.network_name() != repo._format.network_name():
1985
raise AssertionError(
1986
"Mismatched RemoteRepository and stream src %r, %r" % (
1987
src_format.network_name(), repo._format.network_name()))
1990
def missing_parents_chain(self, search, sources):
1991
"""Chain multiple streams together to handle stacking.
1993
:param search: The overall search to satisfy with streams.
1994
:param sources: A list of Repository objects to query.
1996
self.from_serialiser = self.from_repository._format._serializer
1997
self.seen_revs = set()
1998
self.referenced_revs = set()
1999
# If there are heads in the search, or the key count is > 0, we are not
2001
while not search.is_empty() and len(sources) > 1:
2002
source = sources.pop(0)
2003
stream = self._get_stream(source, search)
2004
for kind, substream in stream:
2005
if kind != 'revisions':
2006
yield kind, substream
2008
yield kind, self.missing_parents_rev_handler(substream)
2009
search = search.refine(self.seen_revs, self.referenced_revs)
2010
self.seen_revs = set()
2011
self.referenced_revs = set()
2012
if not search.is_empty():
2013
for kind, stream in self._get_stream(sources[0], search):
2016
def missing_parents_rev_handler(self, substream):
2017
for content in substream:
2018
revision_bytes = content.get_bytes_as('fulltext')
2019
revision = self.from_serialiser.read_revision_from_string(
2021
self.seen_revs.add(content.key[-1])
2022
self.referenced_revs.update(revision.parent_ids)
2026
class RemoteBranchLockableFiles(LockableFiles):
2027
"""A 'LockableFiles' implementation that talks to a smart server.
2029
This is not a public interface class.
2032
def __init__(self, bzrdir, _client):
2033
self.bzrdir = bzrdir
2034
self._client = _client
2035
self._need_find_modes = True
2036
LockableFiles.__init__(
2037
self, bzrdir.get_branch_transport(None),
2038
'lock', lockdir.LockDir)
2040
def _find_modes(self):
2041
# RemoteBranches don't let the client set the mode of control files.
2042
self._dir_mode = None
2043
self._file_mode = None
2046
class RemoteBranchFormat(branch.BranchFormat):
2048
def __init__(self, network_name=None):
2049
super(RemoteBranchFormat, self).__init__()
2050
self._matchingbzrdir = RemoteBzrDirFormat()
2051
self._matchingbzrdir.set_branch_format(self)
2052
self._custom_format = None
2053
self._network_name = network_name
2055
def __eq__(self, other):
2056
return (isinstance(other, RemoteBranchFormat) and
2057
self.__dict__ == other.__dict__)
2059
def _ensure_real(self):
2060
if self._custom_format is None:
2061
self._custom_format = branch.network_format_registry.get(
2064
def get_format_description(self):
2066
return 'Remote: ' + self._custom_format.get_format_description()
2068
def network_name(self):
2069
return self._network_name
2071
def open(self, a_bzrdir, name=None, ignore_fallbacks=False):
2072
return a_bzrdir.open_branch(name=name,
2073
ignore_fallbacks=ignore_fallbacks)
2075
def _vfs_initialize(self, a_bzrdir, name):
2076
# Initialisation when using a local bzrdir object, or a non-vfs init
2077
# method is not available on the server.
2078
# self._custom_format is always set - the start of initialize ensures
2080
if isinstance(a_bzrdir, RemoteBzrDir):
2081
a_bzrdir._ensure_real()
2082
result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2085
# We assume the bzrdir is parameterised; it may not be.
2086
result = self._custom_format.initialize(a_bzrdir, name)
2087
if (isinstance(a_bzrdir, RemoteBzrDir) and
2088
not isinstance(result, RemoteBranch)):
2089
result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2093
def initialize(self, a_bzrdir, name=None):
2094
# 1) get the network name to use.
2095
if self._custom_format:
2096
network_name = self._custom_format.network_name()
2098
# Select the current bzrlib default and ask for that.
2099
reference_bzrdir_format = bzrdir.format_registry.get('default')()
2100
reference_format = reference_bzrdir_format.get_branch_format()
2101
self._custom_format = reference_format
2102
network_name = reference_format.network_name()
2103
# Being asked to create on a non RemoteBzrDir:
2104
if not isinstance(a_bzrdir, RemoteBzrDir):
2105
return self._vfs_initialize(a_bzrdir, name=name)
2106
medium = a_bzrdir._client._medium
2107
if medium._is_remote_before((1, 13)):
2108
return self._vfs_initialize(a_bzrdir, name=name)
2109
# Creating on a remote bzr dir.
2110
# 2) try direct creation via RPC
2111
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2112
if name is not None:
2113
# XXX JRV20100304: Support creating colocated branches
2114
raise errors.NoColocatedBranchSupport(self)
2115
verb = 'BzrDir.create_branch'
2117
response = a_bzrdir._call(verb, path, network_name)
2118
except errors.UnknownSmartMethod:
2119
# Fallback - use vfs methods
2120
medium._remember_remote_is_before((1, 13))
2121
return self._vfs_initialize(a_bzrdir, name=name)
2122
if response[0] != 'ok':
2123
raise errors.UnexpectedSmartServerResponse(response)
2124
# Turn the response into a RemoteRepository object.
2125
format = RemoteBranchFormat(network_name=response[1])
2126
repo_format = response_tuple_to_repo_format(response[3:])
2127
if response[2] == '':
2128
repo_bzrdir = a_bzrdir
2130
repo_bzrdir = RemoteBzrDir(
2131
a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
2133
remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2134
remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2135
format=format, setup_stacking=False, name=name)
2136
# XXX: We know this is a new branch, so it must have revno 0, revid
2137
# NULL_REVISION. Creating the branch locked would make this be unable
2138
# to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2139
remote_branch._last_revision_info_cache = 0, NULL_REVISION
2140
return remote_branch
2142
def make_tags(self, branch):
2144
return self._custom_format.make_tags(branch)
2146
def supports_tags(self):
2147
# Remote branches might support tags, but we won't know until we
2148
# access the real remote branch.
2150
return self._custom_format.supports_tags()
2152
def supports_stacking(self):
2154
return self._custom_format.supports_stacking()
2156
def supports_set_append_revisions_only(self):
2158
return self._custom_format.supports_set_append_revisions_only()
2161
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
2162
"""Branch stored on a server accessed by HPSS RPC.
2164
At the moment most operations are mapped down to simple file operations.
2167
def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
2168
_client=None, format=None, setup_stacking=True, name=None):
2169
"""Create a RemoteBranch instance.
2171
:param real_branch: An optional local implementation of the branch
2172
format, usually accessing the data via the VFS.
2173
:param _client: Private parameter for testing.
2174
:param format: A RemoteBranchFormat object, None to create one
2175
automatically. If supplied it should have a network_name already
2177
:param setup_stacking: If True make an RPC call to determine the
2178
stacked (or not) status of the branch. If False assume the branch
2180
:param name: Colocated branch name
2182
# We intentionally don't call the parent class's __init__, because it
2183
# will try to assign to self.tags, which is a property in this subclass.
2184
# And the parent's __init__ doesn't do much anyway.
2185
self.bzrdir = remote_bzrdir
2186
if _client is not None:
2187
self._client = _client
2189
self._client = remote_bzrdir._client
2190
self.repository = remote_repository
2191
if real_branch is not None:
2192
self._real_branch = real_branch
2193
# Give the remote repository the matching real repo.
2194
real_repo = self._real_branch.repository
2195
if isinstance(real_repo, RemoteRepository):
2196
real_repo._ensure_real()
2197
real_repo = real_repo._real_repository
2198
self.repository._set_real_repository(real_repo)
2199
# Give the branch the remote repository to let fast-pathing happen.
2200
self._real_branch.repository = self.repository
2202
self._real_branch = None
2203
# Fill out expected attributes of branch for bzrlib API users.
2204
self._clear_cached_state()
2205
# TODO: deprecate self.base in favor of user_url
2206
self.base = self.bzrdir.user_url
2208
self._control_files = None
2209
self._lock_mode = None
2210
self._lock_token = None
2211
self._repo_lock_token = None
2212
self._lock_count = 0
2213
self._leave_lock = False
2214
# Setup a format: note that we cannot call _ensure_real until all the
2215
# attributes above are set: This code cannot be moved higher up in this
2218
self._format = RemoteBranchFormat()
2219
if real_branch is not None:
2220
self._format._network_name = \
2221
self._real_branch._format.network_name()
2223
self._format = format
2224
# when we do _ensure_real we may need to pass ignore_fallbacks to the
2225
# branch.open_branch method.
2226
self._real_ignore_fallbacks = not setup_stacking
2227
if not self._format._network_name:
2228
# Did not get from open_branchV2 - old server.
2230
self._format._network_name = \
2231
self._real_branch._format.network_name()
2232
self.tags = self._format.make_tags(self)
2233
# The base class init is not called, so we duplicate this:
2234
hooks = branch.Branch.hooks['open']
2237
self._is_stacked = False
2239
self._setup_stacking()
2241
def _setup_stacking(self):
2242
# configure stacking into the remote repository, by reading it from
2245
fallback_url = self.get_stacked_on_url()
2246
except (errors.NotStacked, errors.UnstackableBranchFormat,
2247
errors.UnstackableRepositoryFormat), e:
2249
self._is_stacked = True
2250
self._activate_fallback_location(fallback_url)
2252
def _get_config(self):
2253
return RemoteBranchConfig(self)
2255
def _get_real_transport(self):
2256
# if we try vfs access, return the real branch's vfs transport
2258
return self._real_branch._transport
2260
_transport = property(_get_real_transport)
2263
return "%s(%s)" % (self.__class__.__name__, self.base)
2267
def _ensure_real(self):
2268
"""Ensure that there is a _real_branch set.
2270
Used before calls to self._real_branch.
2272
if self._real_branch is None:
2273
if not vfs.vfs_enabled():
2274
raise AssertionError('smart server vfs must be enabled '
2275
'to use vfs implementation')
2276
self.bzrdir._ensure_real()
2277
self._real_branch = self.bzrdir._real_bzrdir.open_branch(
2278
ignore_fallbacks=self._real_ignore_fallbacks, name=self._name)
2279
if self.repository._real_repository is None:
2280
# Give the remote repository the matching real repo.
2281
real_repo = self._real_branch.repository
2282
if isinstance(real_repo, RemoteRepository):
2283
real_repo._ensure_real()
2284
real_repo = real_repo._real_repository
2285
self.repository._set_real_repository(real_repo)
2286
# Give the real branch the remote repository to let fast-pathing
2288
self._real_branch.repository = self.repository
2289
if self._lock_mode == 'r':
2290
self._real_branch.lock_read()
2291
elif self._lock_mode == 'w':
2292
self._real_branch.lock_write(token=self._lock_token)
2294
def _translate_error(self, err, **context):
2295
self.repository._translate_error(err, branch=self, **context)
2297
def _clear_cached_state(self):
2298
super(RemoteBranch, self)._clear_cached_state()
2299
if self._real_branch is not None:
2300
self._real_branch._clear_cached_state()
2302
def _clear_cached_state_of_remote_branch_only(self):
2303
"""Like _clear_cached_state, but doesn't clear the cache of
2306
This is useful when falling back to calling a method of
2307
self._real_branch that changes state. In that case the underlying
2308
branch changes, so we need to invalidate this RemoteBranch's cache of
2309
it. However, there's no need to invalidate the _real_branch's cache
2310
too, in fact doing so might harm performance.
2312
super(RemoteBranch, self)._clear_cached_state()
2315
def control_files(self):
2316
# Defer actually creating RemoteBranchLockableFiles until its needed,
2317
# because it triggers an _ensure_real that we otherwise might not need.
2318
if self._control_files is None:
2319
self._control_files = RemoteBranchLockableFiles(
2320
self.bzrdir, self._client)
2321
return self._control_files
2323
def _get_checkout_format(self):
2325
return self._real_branch._get_checkout_format()
2327
def get_physical_lock_status(self):
2328
"""See Branch.get_physical_lock_status()."""
2329
# should be an API call to the server, as branches must be lockable.
2331
return self._real_branch.get_physical_lock_status()
2333
def get_stacked_on_url(self):
2334
"""Get the URL this branch is stacked against.
2336
:raises NotStacked: If the branch is not stacked.
2337
:raises UnstackableBranchFormat: If the branch does not support
2339
:raises UnstackableRepositoryFormat: If the repository does not support
2343
# there may not be a repository yet, so we can't use
2344
# self._translate_error, so we can't use self._call either.
2345
response = self._client.call('Branch.get_stacked_on_url',
2346
self._remote_path())
2347
except errors.ErrorFromSmartServer, err:
2348
# there may not be a repository yet, so we can't call through
2349
# its _translate_error
2350
_translate_error(err, branch=self)
2351
except errors.UnknownSmartMethod, err:
2353
return self._real_branch.get_stacked_on_url()
2354
if response[0] != 'ok':
2355
raise errors.UnexpectedSmartServerResponse(response)
2358
def set_stacked_on_url(self, url):
2359
branch.Branch.set_stacked_on_url(self, url)
2361
self._is_stacked = False
2363
self._is_stacked = True
2365
def _vfs_get_tags_bytes(self):
2367
return self._real_branch._get_tags_bytes()
2369
def _get_tags_bytes(self):
2370
medium = self._client._medium
2371
if medium._is_remote_before((1, 13)):
2372
return self._vfs_get_tags_bytes()
2374
response = self._call('Branch.get_tags_bytes', self._remote_path())
2375
except errors.UnknownSmartMethod:
2376
medium._remember_remote_is_before((1, 13))
2377
return self._vfs_get_tags_bytes()
2380
def _vfs_set_tags_bytes(self, bytes):
2382
return self._real_branch._set_tags_bytes(bytes)
2384
def _set_tags_bytes(self, bytes):
2385
medium = self._client._medium
2386
if medium._is_remote_before((1, 18)):
2387
self._vfs_set_tags_bytes(bytes)
2391
self._remote_path(), self._lock_token, self._repo_lock_token)
2392
response = self._call_with_body_bytes(
2393
'Branch.set_tags_bytes', args, bytes)
2394
except errors.UnknownSmartMethod:
2395
medium._remember_remote_is_before((1, 18))
2396
self._vfs_set_tags_bytes(bytes)
2398
def lock_read(self):
2399
"""Lock the branch for read operations.
2401
:return: A bzrlib.lock.LogicalLockResult.
2403
self.repository.lock_read()
2404
if not self._lock_mode:
2405
self._note_lock('r')
2406
self._lock_mode = 'r'
2407
self._lock_count = 1
2408
if self._real_branch is not None:
2409
self._real_branch.lock_read()
2411
self._lock_count += 1
2412
return lock.LogicalLockResult(self.unlock)
2414
def _remote_lock_write(self, token):
2416
branch_token = repo_token = ''
2418
branch_token = token
2419
repo_token = self.repository.lock_write().repository_token
2420
self.repository.unlock()
2421
err_context = {'token': token}
2422
response = self._call(
2423
'Branch.lock_write', self._remote_path(), branch_token,
2424
repo_token or '', **err_context)
2425
if response[0] != 'ok':
2426
raise errors.UnexpectedSmartServerResponse(response)
2427
ok, branch_token, repo_token = response
2428
return branch_token, repo_token
2430
def lock_write(self, token=None):
2431
if not self._lock_mode:
2432
self._note_lock('w')
2433
# Lock the branch and repo in one remote call.
2434
remote_tokens = self._remote_lock_write(token)
2435
self._lock_token, self._repo_lock_token = remote_tokens
2436
if not self._lock_token:
2437
raise SmartProtocolError('Remote server did not return a token!')
2438
# Tell the self.repository object that it is locked.
2439
self.repository.lock_write(
2440
self._repo_lock_token, _skip_rpc=True)
2442
if self._real_branch is not None:
2443
self._real_branch.lock_write(token=self._lock_token)
2444
if token is not None:
2445
self._leave_lock = True
2447
self._leave_lock = False
2448
self._lock_mode = 'w'
2449
self._lock_count = 1
2450
elif self._lock_mode == 'r':
2451
raise errors.ReadOnlyTransaction
2453
if token is not None:
2454
# A token was given to lock_write, and we're relocking, so
2455
# check that the given token actually matches the one we
2457
if token != self._lock_token:
2458
raise errors.TokenMismatch(token, self._lock_token)
2459
self._lock_count += 1
2460
# Re-lock the repository too.
2461
self.repository.lock_write(self._repo_lock_token)
2462
return BranchWriteLockResult(self.unlock, self._lock_token or None)
2464
def _unlock(self, branch_token, repo_token):
2465
err_context = {'token': str((branch_token, repo_token))}
2466
response = self._call(
2467
'Branch.unlock', self._remote_path(), branch_token,
2468
repo_token or '', **err_context)
2469
if response == ('ok',):
2471
raise errors.UnexpectedSmartServerResponse(response)
2473
@only_raises(errors.LockNotHeld, errors.LockBroken)
2476
self._lock_count -= 1
2477
if not self._lock_count:
2478
self._clear_cached_state()
2479
mode = self._lock_mode
2480
self._lock_mode = None
2481
if self._real_branch is not None:
2482
if (not self._leave_lock and mode == 'w' and
2483
self._repo_lock_token):
2484
# If this RemoteBranch will remove the physical lock
2485
# for the repository, make sure the _real_branch
2486
# doesn't do it first. (Because the _real_branch's
2487
# repository is set to be the RemoteRepository.)
2488
self._real_branch.repository.leave_lock_in_place()
2489
self._real_branch.unlock()
2491
# Only write-locked branched need to make a remote method
2492
# call to perform the unlock.
2494
if not self._lock_token:
2495
raise AssertionError('Locked, but no token!')
2496
branch_token = self._lock_token
2497
repo_token = self._repo_lock_token
2498
self._lock_token = None
2499
self._repo_lock_token = None
2500
if not self._leave_lock:
2501
self._unlock(branch_token, repo_token)
2503
self.repository.unlock()
2505
def break_lock(self):
2507
return self._real_branch.break_lock()
2509
def leave_lock_in_place(self):
2510
if not self._lock_token:
2511
raise NotImplementedError(self.leave_lock_in_place)
2512
self._leave_lock = True
2514
def dont_leave_lock_in_place(self):
2515
if not self._lock_token:
2516
raise NotImplementedError(self.dont_leave_lock_in_place)
2517
self._leave_lock = False
2520
def get_rev_id(self, revno, history=None):
2522
return _mod_revision.NULL_REVISION
2523
last_revision_info = self.last_revision_info()
2524
ok, result = self.repository.get_rev_id_for_revno(
2525
revno, last_revision_info)
2528
missing_parent = result[1]
2529
# Either the revision named by the server is missing, or its parent
2530
# is. Call get_parent_map to determine which, so that we report a
2532
parent_map = self.repository.get_parent_map([missing_parent])
2533
if missing_parent in parent_map:
2534
missing_parent = parent_map[missing_parent]
2535
raise errors.RevisionNotPresent(missing_parent, self.repository)
2537
def _last_revision_info(self):
2538
response = self._call('Branch.last_revision_info', self._remote_path())
2539
if response[0] != 'ok':
2540
raise SmartProtocolError('unexpected response code %s' % (response,))
2541
revno = int(response[1])
2542
last_revision = response[2]
2543
return (revno, last_revision)
2545
def _gen_revision_history(self):
2546
"""See Branch._gen_revision_history()."""
2547
if self._is_stacked:
2549
return self._real_branch._gen_revision_history()
2550
response_tuple, response_handler = self._call_expecting_body(
2551
'Branch.revision_history', self._remote_path())
2552
if response_tuple[0] != 'ok':
2553
raise errors.UnexpectedSmartServerResponse(response_tuple)
2554
result = response_handler.read_body_bytes().split('\x00')
2559
def _remote_path(self):
2560
return self.bzrdir._path_for_remote_call(self._client)
2562
def _set_last_revision_descendant(self, revision_id, other_branch,
2563
allow_diverged=False, allow_overwrite_descendant=False):
2564
# This performs additional work to meet the hook contract; while its
2565
# undesirable, we have to synthesise the revno to call the hook, and
2566
# not calling the hook is worse as it means changes can't be prevented.
2567
# Having calculated this though, we can't just call into
2568
# set_last_revision_info as a simple call, because there is a set_rh
2569
# hook that some folk may still be using.
2570
old_revno, old_revid = self.last_revision_info()
2571
history = self._lefthand_history(revision_id)
2572
self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2573
err_context = {'other_branch': other_branch}
2574
response = self._call('Branch.set_last_revision_ex',
2575
self._remote_path(), self._lock_token, self._repo_lock_token,
2576
revision_id, int(allow_diverged), int(allow_overwrite_descendant),
2578
self._clear_cached_state()
2579
if len(response) != 3 and response[0] != 'ok':
2580
raise errors.UnexpectedSmartServerResponse(response)
2581
new_revno, new_revision_id = response[1:]
2582
self._last_revision_info_cache = new_revno, new_revision_id
2583
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2584
if self._real_branch is not None:
2585
cache = new_revno, new_revision_id
2586
self._real_branch._last_revision_info_cache = cache
2588
def _set_last_revision(self, revision_id):
2589
old_revno, old_revid = self.last_revision_info()
2590
# This performs additional work to meet the hook contract; while its
2591
# undesirable, we have to synthesise the revno to call the hook, and
2592
# not calling the hook is worse as it means changes can't be prevented.
2593
# Having calculated this though, we can't just call into
2594
# set_last_revision_info as a simple call, because there is a set_rh
2595
# hook that some folk may still be using.
2596
history = self._lefthand_history(revision_id)
2597
self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2598
self._clear_cached_state()
2599
response = self._call('Branch.set_last_revision',
2600
self._remote_path(), self._lock_token, self._repo_lock_token,
2602
if response != ('ok',):
2603
raise errors.UnexpectedSmartServerResponse(response)
2604
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2607
def set_revision_history(self, rev_history):
2608
# Send just the tip revision of the history; the server will generate
2609
# the full history from that. If the revision doesn't exist in this
2610
# branch, NoSuchRevision will be raised.
2611
if rev_history == []:
2614
rev_id = rev_history[-1]
2615
self._set_last_revision(rev_id)
2616
for hook in branch.Branch.hooks['set_rh']:
2617
hook(self, rev_history)
2618
self._cache_revision_history(rev_history)
2620
def _get_parent_location(self):
2621
medium = self._client._medium
2622
if medium._is_remote_before((1, 13)):
2623
return self._vfs_get_parent_location()
2625
response = self._call('Branch.get_parent', self._remote_path())
2626
except errors.UnknownSmartMethod:
2627
medium._remember_remote_is_before((1, 13))
2628
return self._vfs_get_parent_location()
2629
if len(response) != 1:
2630
raise errors.UnexpectedSmartServerResponse(response)
2631
parent_location = response[0]
2632
if parent_location == '':
2634
return parent_location
2636
def _vfs_get_parent_location(self):
2638
return self._real_branch._get_parent_location()
2640
def _set_parent_location(self, url):
2641
medium = self._client._medium
2642
if medium._is_remote_before((1, 15)):
2643
return self._vfs_set_parent_location(url)
2645
call_url = url or ''
2646
if type(call_url) is not str:
2647
raise AssertionError('url must be a str or None (%s)' % url)
2648
response = self._call('Branch.set_parent_location',
2649
self._remote_path(), self._lock_token, self._repo_lock_token,
2651
except errors.UnknownSmartMethod:
2652
medium._remember_remote_is_before((1, 15))
2653
return self._vfs_set_parent_location(url)
2655
raise errors.UnexpectedSmartServerResponse(response)
2657
def _vfs_set_parent_location(self, url):
2659
return self._real_branch._set_parent_location(url)
2662
def pull(self, source, overwrite=False, stop_revision=None,
2664
self._clear_cached_state_of_remote_branch_only()
2666
return self._real_branch.pull(
2667
source, overwrite=overwrite, stop_revision=stop_revision,
2668
_override_hook_target=self, **kwargs)
2671
def push(self, target, overwrite=False, stop_revision=None):
2673
return self._real_branch.push(
2674
target, overwrite=overwrite, stop_revision=stop_revision,
2675
_override_hook_source_branch=self)
2677
def is_locked(self):
2678
return self._lock_count >= 1
2681
def revision_id_to_revno(self, revision_id):
2683
return self._real_branch.revision_id_to_revno(revision_id)
2686
def set_last_revision_info(self, revno, revision_id):
2687
# XXX: These should be returned by the set_last_revision_info verb
2688
old_revno, old_revid = self.last_revision_info()
2689
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2690
revision_id = ensure_null(revision_id)
2692
response = self._call('Branch.set_last_revision_info',
2693
self._remote_path(), self._lock_token, self._repo_lock_token,
2694
str(revno), revision_id)
2695
except errors.UnknownSmartMethod:
2697
self._clear_cached_state_of_remote_branch_only()
2698
self._real_branch.set_last_revision_info(revno, revision_id)
2699
self._last_revision_info_cache = revno, revision_id
2701
if response == ('ok',):
2702
self._clear_cached_state()
2703
self._last_revision_info_cache = revno, revision_id
2704
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2705
# Update the _real_branch's cache too.
2706
if self._real_branch is not None:
2707
cache = self._last_revision_info_cache
2708
self._real_branch._last_revision_info_cache = cache
2710
raise errors.UnexpectedSmartServerResponse(response)
2713
def generate_revision_history(self, revision_id, last_rev=None,
2715
medium = self._client._medium
2716
if not medium._is_remote_before((1, 6)):
2717
# Use a smart method for 1.6 and above servers
2719
self._set_last_revision_descendant(revision_id, other_branch,
2720
allow_diverged=True, allow_overwrite_descendant=True)
2722
except errors.UnknownSmartMethod:
2723
medium._remember_remote_is_before((1, 6))
2724
self._clear_cached_state_of_remote_branch_only()
2725
self.set_revision_history(self._lefthand_history(revision_id,
2726
last_rev=last_rev,other_branch=other_branch))
2728
def set_push_location(self, location):
2730
return self._real_branch.set_push_location(location)
2733
class RemoteConfig(object):
2734
"""A Config that reads and writes from smart verbs.
2736
It is a low-level object that considers config data to be name/value pairs
2737
that may be associated with a section. Assigning meaning to the these
2738
values is done at higher levels like bzrlib.config.TreeConfig.
2741
def get_option(self, name, section=None, default=None):
2742
"""Return the value associated with a named option.
2744
:param name: The name of the value
2745
:param section: The section the option is in (if any)
2746
:param default: The value to return if the value is not set
2747
:return: The value or default value
2750
configobj = self._get_configobj()
2752
section_obj = configobj
2755
section_obj = configobj[section]
2758
return section_obj.get(name, default)
2759
except errors.UnknownSmartMethod:
2760
return self._vfs_get_option(name, section, default)
2762
def _response_to_configobj(self, response):
2763
if len(response[0]) and response[0][0] != 'ok':
2764
raise errors.UnexpectedSmartServerResponse(response)
2765
lines = response[1].read_body_bytes().splitlines()
2766
return config.ConfigObj(lines, encoding='utf-8')
2769
class RemoteBranchConfig(RemoteConfig):
2770
"""A RemoteConfig for Branches."""
2772
def __init__(self, branch):
2773
self._branch = branch
2775
def _get_configobj(self):
2776
path = self._branch._remote_path()
2777
response = self._branch._client.call_expecting_body(
2778
'Branch.get_config_file', path)
2779
return self._response_to_configobj(response)
2781
def set_option(self, value, name, section=None):
2782
"""Set the value associated with a named option.
2784
:param value: The value to set
2785
:param name: The name of the value to set
2786
:param section: The section the option is in (if any)
2788
medium = self._branch._client._medium
2789
if medium._is_remote_before((1, 14)):
2790
return self._vfs_set_option(value, name, section)
2792
path = self._branch._remote_path()
2793
response = self._branch._client.call('Branch.set_config_option',
2794
path, self._branch._lock_token, self._branch._repo_lock_token,
2795
value.encode('utf8'), name, section or '')
2796
except errors.UnknownSmartMethod:
2797
medium._remember_remote_is_before((1, 14))
2798
return self._vfs_set_option(value, name, section)
2800
raise errors.UnexpectedSmartServerResponse(response)
2802
def _real_object(self):
2803
self._branch._ensure_real()
2804
return self._branch._real_branch
2806
def _vfs_set_option(self, value, name, section=None):
2807
return self._real_object()._get_config().set_option(
2808
value, name, section)
2811
class RemoteBzrDirConfig(RemoteConfig):
2812
"""A RemoteConfig for BzrDirs."""
2814
def __init__(self, bzrdir):
2815
self._bzrdir = bzrdir
2817
def _get_configobj(self):
2818
medium = self._bzrdir._client._medium
2819
verb = 'BzrDir.get_config_file'
2820
if medium._is_remote_before((1, 15)):
2821
raise errors.UnknownSmartMethod(verb)
2822
path = self._bzrdir._path_for_remote_call(self._bzrdir._client)
2823
response = self._bzrdir._call_expecting_body(
2825
return self._response_to_configobj(response)
2827
def _vfs_get_option(self, name, section, default):
2828
return self._real_object()._get_config().get_option(
2829
name, section, default)
2831
def set_option(self, value, name, section=None):
2832
"""Set the value associated with a named option.
2834
:param value: The value to set
2835
:param name: The name of the value to set
2836
:param section: The section the option is in (if any)
2838
return self._real_object()._get_config().set_option(
2839
value, name, section)
2841
def _real_object(self):
2842
self._bzrdir._ensure_real()
2843
return self._bzrdir._real_bzrdir
2847
def _extract_tar(tar, to_dir):
2848
"""Extract all the contents of a tarfile object.
2850
A replacement for extractall, which is not present in python2.4
2853
tar.extract(tarinfo, to_dir)
2856
def _translate_error(err, **context):
2857
"""Translate an ErrorFromSmartServer into a more useful error.
2859
Possible context keys:
2867
If the error from the server doesn't match a known pattern, then
2868
UnknownErrorFromSmartServer is raised.
2872
return context[name]
2873
except KeyError, key_err:
2874
mutter('Missing key %r in context %r', key_err.args[0], context)
2877
"""Get the path from the context if present, otherwise use first error
2881
return context['path']
2882
except KeyError, key_err:
2884
return err.error_args[0]
2885
except IndexError, idx_err:
2887
'Missing key %r in context %r', key_err.args[0], context)
2890
if err.error_verb == 'IncompatibleRepositories':
2891
raise errors.IncompatibleRepositories(err.error_args[0],
2892
err.error_args[1], err.error_args[2])
2893
elif err.error_verb == 'NoSuchRevision':
2894
raise NoSuchRevision(find('branch'), err.error_args[0])
2895
elif err.error_verb == 'nosuchrevision':
2896
raise NoSuchRevision(find('repository'), err.error_args[0])
2897
elif err.error_verb == 'nobranch':
2898
if len(err.error_args) >= 1:
2899
extra = err.error_args[0]
2902
raise errors.NotBranchError(path=find('bzrdir').root_transport.base,
2904
elif err.error_verb == 'norepository':
2905
raise errors.NoRepositoryPresent(find('bzrdir'))
2906
elif err.error_verb == 'LockContention':
2907
raise errors.LockContention('(remote lock)')
2908
elif err.error_verb == 'UnlockableTransport':
2909
raise errors.UnlockableTransport(find('bzrdir').root_transport)
2910
elif err.error_verb == 'LockFailed':
2911
raise errors.LockFailed(err.error_args[0], err.error_args[1])
2912
elif err.error_verb == 'TokenMismatch':
2913
raise errors.TokenMismatch(find('token'), '(remote token)')
2914
elif err.error_verb == 'Diverged':
2915
raise errors.DivergedBranches(find('branch'), find('other_branch'))
2916
elif err.error_verb == 'TipChangeRejected':
2917
raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
2918
elif err.error_verb == 'UnstackableBranchFormat':
2919
raise errors.UnstackableBranchFormat(*err.error_args)
2920
elif err.error_verb == 'UnstackableRepositoryFormat':
2921
raise errors.UnstackableRepositoryFormat(*err.error_args)
2922
elif err.error_verb == 'NotStacked':
2923
raise errors.NotStacked(branch=find('branch'))
2924
elif err.error_verb == 'PermissionDenied':
2926
if len(err.error_args) >= 2:
2927
extra = err.error_args[1]
2930
raise errors.PermissionDenied(path, extra=extra)
2931
elif err.error_verb == 'ReadError':
2933
raise errors.ReadError(path)
2934
elif err.error_verb == 'NoSuchFile':
2936
raise errors.NoSuchFile(path)
2937
elif err.error_verb == 'FileExists':
2938
raise errors.FileExists(err.error_args[0])
2939
elif err.error_verb == 'DirectoryNotEmpty':
2940
raise errors.DirectoryNotEmpty(err.error_args[0])
2941
elif err.error_verb == 'ShortReadvError':
2942
args = err.error_args
2943
raise errors.ShortReadvError(
2944
args[0], int(args[1]), int(args[2]), int(args[3]))
2945
elif err.error_verb in ('UnicodeEncodeError', 'UnicodeDecodeError'):
2946
encoding = str(err.error_args[0]) # encoding must always be a string
2947
val = err.error_args[1]
2948
start = int(err.error_args[2])
2949
end = int(err.error_args[3])
2950
reason = str(err.error_args[4]) # reason must always be a string
2951
if val.startswith('u:'):
2952
val = val[2:].decode('utf-8')
2953
elif val.startswith('s:'):
2954
val = val[2:].decode('base64')
2955
if err.error_verb == 'UnicodeDecodeError':
2956
raise UnicodeDecodeError(encoding, val, start, end, reason)
2957
elif err.error_verb == 'UnicodeEncodeError':
2958
raise UnicodeEncodeError(encoding, val, start, end, reason)
2959
elif err.error_verb == 'ReadOnlyError':
2960
raise errors.TransportNotPossible('readonly transport')
2961
raise errors.UnknownErrorFromSmartServer(err)
added
removed
bzrlib/remote.py
