1
# Copyright (C) 2006, 2007, 2008 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
17
# TODO: At some point, handle upgrades by just passing the whole request
18
# across to run on the server.
33
revision as _mod_revision,
37
from bzrlib.branch import BranchReferenceFormat
38
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
39
from bzrlib.decorators import needs_read_lock, needs_write_lock
40
from bzrlib.errors import (
44
from bzrlib.lockable_files import LockableFiles
45
from bzrlib.smart import client, vfs, repository as smart_repo
46
from bzrlib.revision import ensure_null, NULL_REVISION
47
from bzrlib.trace import mutter, note, warning
48
from bzrlib.util import bencode
51
class _RpcHelper(object):
52
"""Mixin class that helps with issuing RPCs."""
54
def _call(self, method, *args, **err_context):
56
return self._client.call(method, *args)
57
except errors.ErrorFromSmartServer, err:
58
self._translate_error(err, **err_context)
60
def _call_expecting_body(self, method, *args, **err_context):
62
return self._client.call_expecting_body(method, *args)
63
except errors.ErrorFromSmartServer, err:
64
self._translate_error(err, **err_context)
66
def _call_with_body_bytes_expecting_body(self, method, args, body_bytes,
69
return self._client.call_with_body_bytes_expecting_body(
70
method, args, body_bytes)
71
except errors.ErrorFromSmartServer, err:
72
self._translate_error(err, **err_context)
75
def response_tuple_to_repo_format(response):
76
"""Convert a response tuple describing a repository format to a format."""
77
format = RemoteRepositoryFormat()
78
format._rich_root_data = (response[0] == 'yes')
79
format._supports_tree_reference = (response[1] == 'yes')
80
format._supports_external_lookups = (response[2] == 'yes')
81
format._network_name = response[3]
85
# Note: RemoteBzrDirFormat is in bzrdir.py
87
class RemoteBzrDir(BzrDir, _RpcHelper):
88
"""Control directory on a remote server, accessed via bzr:// or similar."""
90
def __init__(self, transport, format, _client=None):
91
"""Construct a RemoteBzrDir.
93
:param _client: Private parameter for testing. Disables probing and the
96
BzrDir.__init__(self, transport, format)
97
# this object holds a delegated bzrdir that uses file-level operations
98
# to talk to the other side
99
self._real_bzrdir = None
100
# 1-shot cache for the call pattern 'create_branch; open_branch' - see
101
# create_branch for details.
102
self._next_open_branch_result = None
105
medium = transport.get_smart_medium()
106
self._client = client._SmartClient(medium)
108
self._client = _client
111
path = self._path_for_remote_call(self._client)
112
response = self._call('BzrDir.open', path)
113
if response not in [('yes',), ('no',)]:
114
raise errors.UnexpectedSmartServerResponse(response)
115
if response == ('no',):
116
raise errors.NotBranchError(path=transport.base)
118
def _ensure_real(self):
119
"""Ensure that there is a _real_bzrdir set.
121
Used before calls to self._real_bzrdir.
123
if not self._real_bzrdir:
124
self._real_bzrdir = BzrDir.open_from_transport(
125
self.root_transport, _server_formats=False)
126
self._format._network_name = \
127
self._real_bzrdir._format.network_name()
129
def _translate_error(self, err, **context):
130
_translate_error(err, bzrdir=self, **context)
132
def break_lock(self):
133
# Prevent aliasing problems in the next_open_branch_result cache.
134
# See create_branch for rationale.
135
self._next_open_branch_result = None
136
return BzrDir.break_lock(self)
138
def _vfs_cloning_metadir(self, require_stacking=False):
140
return self._real_bzrdir.cloning_metadir(
141
require_stacking=require_stacking)
143
def cloning_metadir(self, require_stacking=False):
144
medium = self._client._medium
145
if medium._is_remote_before((1, 13)):
146
return self._vfs_cloning_metadir(require_stacking=require_stacking)
147
verb = 'BzrDir.cloning_metadir'
152
path = self._path_for_remote_call(self._client)
154
response = self._call(verb, path, stacking)
155
except errors.UnknownSmartMethod:
156
medium._remember_remote_is_before((1, 13))
157
return self._vfs_cloning_metadir(require_stacking=require_stacking)
158
except errors.UnknownErrorFromSmartServer, err:
159
if err.error_tuple != ('BranchReference',):
161
# We need to resolve the branch reference to determine the
162
# cloning_metadir. This causes unnecessary RPCs to open the
163
# referenced branch (and bzrdir, etc) but only when the caller
164
# didn't already resolve the branch reference.
165
referenced_branch = self.open_branch()
166
return referenced_branch.bzrdir.cloning_metadir()
167
if len(response) != 3:
168
raise errors.UnexpectedSmartServerResponse(response)
169
control_name, repo_name, branch_info = response
170
if len(branch_info) != 2:
171
raise errors.UnexpectedSmartServerResponse(response)
172
branch_ref, branch_name = branch_info
173
format = bzrdir.network_format_registry.get(control_name)
175
format.repository_format = repository.network_format_registry.get(
177
if branch_ref == 'ref':
178
# XXX: we need possible_transports here to avoid reopening the
179
# connection to the referenced location
180
ref_bzrdir = BzrDir.open(branch_name)
181
branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
182
format.set_branch_format(branch_format)
183
elif branch_ref == 'branch':
185
format.set_branch_format(
186
branch.network_format_registry.get(branch_name))
188
raise errors.UnexpectedSmartServerResponse(response)
191
def create_repository(self, shared=False):
192
# as per meta1 formats - just delegate to the format object which may
194
result = self._format.repository_format.initialize(self, shared)
195
if not isinstance(result, RemoteRepository):
196
return self.open_repository()
200
def destroy_repository(self):
201
"""See BzrDir.destroy_repository"""
203
self._real_bzrdir.destroy_repository()
205
def create_branch(self):
206
# as per meta1 formats - just delegate to the format object which may
208
real_branch = self._format.get_branch_format().initialize(self)
209
if not isinstance(real_branch, RemoteBranch):
210
result = RemoteBranch(self, self.find_repository(), real_branch)
213
# BzrDir.clone_on_transport() uses the result of create_branch but does
214
# not return it to its callers; we save approximately 8% of our round
215
# trips by handing the branch we created back to the first caller to
216
# open_branch rather than probing anew. Long term we need a API in
217
# bzrdir that doesn't discard result objects (like result_branch).
219
self._next_open_branch_result = result
222
def destroy_branch(self):
223
"""See BzrDir.destroy_branch"""
225
self._real_bzrdir.destroy_branch()
226
self._next_open_branch_result = None
228
def create_workingtree(self, revision_id=None, from_branch=None):
229
raise errors.NotLocalUrl(self.transport.base)
231
def find_branch_format(self):
232
"""Find the branch 'format' for this bzrdir.
234
This might be a synthetic object for e.g. RemoteBranch and SVN.
236
b = self.open_branch()
239
def get_branch_reference(self):
240
"""See BzrDir.get_branch_reference()."""
241
response = self._get_branch_reference()
242
if response[0] == 'ref':
247
def _get_branch_reference(self):
248
path = self._path_for_remote_call(self._client)
249
medium = self._client._medium
250
if not medium._is_remote_before((1, 13)):
252
response = self._call('BzrDir.open_branchV2', path)
253
if response[0] not in ('ref', 'branch'):
254
raise errors.UnexpectedSmartServerResponse(response)
256
except errors.UnknownSmartMethod:
257
medium._remember_remote_is_before((1, 13))
258
response = self._call('BzrDir.open_branch', path)
259
if response[0] != 'ok':
260
raise errors.UnexpectedSmartServerResponse(response)
261
if response[1] != '':
262
return ('ref', response[1])
264
return ('branch', '')
266
def _get_tree_branch(self):
267
"""See BzrDir._get_tree_branch()."""
268
return None, self.open_branch()
270
def open_branch(self, _unsupported=False, ignore_fallbacks=False):
272
raise NotImplementedError('unsupported flag support not implemented yet.')
273
if self._next_open_branch_result is not None:
274
# See create_branch for details.
275
result = self._next_open_branch_result
276
self._next_open_branch_result = None
278
response = self._get_branch_reference()
279
if response[0] == 'ref':
280
# a branch reference, use the existing BranchReference logic.
281
format = BranchReferenceFormat()
282
return format.open(self, _found=True, location=response[1],
283
ignore_fallbacks=ignore_fallbacks)
284
branch_format_name = response[1]
285
if not branch_format_name:
286
branch_format_name = None
287
format = RemoteBranchFormat(network_name=branch_format_name)
288
return RemoteBranch(self, self.find_repository(), format=format,
289
setup_stacking=not ignore_fallbacks)
291
def _open_repo_v1(self, path):
292
verb = 'BzrDir.find_repository'
293
response = self._call(verb, path)
294
if response[0] != 'ok':
295
raise errors.UnexpectedSmartServerResponse(response)
296
# servers that only support the v1 method don't support external
299
repo = self._real_bzrdir.open_repository()
300
response = response + ('no', repo._format.network_name())
301
return response, repo
303
def _open_repo_v2(self, path):
304
verb = 'BzrDir.find_repositoryV2'
305
response = self._call(verb, path)
306
if response[0] != 'ok':
307
raise errors.UnexpectedSmartServerResponse(response)
309
repo = self._real_bzrdir.open_repository()
310
response = response + (repo._format.network_name(),)
311
return response, repo
313
def _open_repo_v3(self, path):
314
verb = 'BzrDir.find_repositoryV3'
315
medium = self._client._medium
316
if medium._is_remote_before((1, 13)):
317
raise errors.UnknownSmartMethod(verb)
319
response = self._call(verb, path)
320
except errors.UnknownSmartMethod:
321
medium._remember_remote_is_before((1, 13))
323
if response[0] != 'ok':
324
raise errors.UnexpectedSmartServerResponse(response)
325
return response, None
327
def open_repository(self):
328
path = self._path_for_remote_call(self._client)
330
for probe in [self._open_repo_v3, self._open_repo_v2,
333
response, real_repo = probe(path)
335
except errors.UnknownSmartMethod:
338
raise errors.UnknownSmartMethod('BzrDir.find_repository{3,2,}')
339
if response[0] != 'ok':
340
raise errors.UnexpectedSmartServerResponse(response)
341
if len(response) != 6:
342
raise SmartProtocolError('incorrect response length %s' % (response,))
343
if response[1] == '':
344
# repo is at this dir.
345
format = response_tuple_to_repo_format(response[2:])
346
# Used to support creating a real format instance when needed.
347
format._creating_bzrdir = self
348
remote_repo = RemoteRepository(self, format)
349
format._creating_repo = remote_repo
350
if real_repo is not None:
351
remote_repo._set_real_repository(real_repo)
354
raise errors.NoRepositoryPresent(self)
356
def open_workingtree(self, recommend_upgrade=True):
358
if self._real_bzrdir.has_workingtree():
359
raise errors.NotLocalUrl(self.root_transport)
361
raise errors.NoWorkingTree(self.root_transport.base)
363
def _path_for_remote_call(self, client):
364
"""Return the path to be used for this bzrdir in a remote call."""
365
return client.remote_path_from_transport(self.root_transport)
367
def get_branch_transport(self, branch_format):
369
return self._real_bzrdir.get_branch_transport(branch_format)
371
def get_repository_transport(self, repository_format):
373
return self._real_bzrdir.get_repository_transport(repository_format)
375
def get_workingtree_transport(self, workingtree_format):
377
return self._real_bzrdir.get_workingtree_transport(workingtree_format)
379
def can_convert_format(self):
380
"""Upgrading of remote bzrdirs is not supported yet."""
383
def needs_format_conversion(self, format=None):
384
"""Upgrading of remote bzrdirs is not supported yet."""
386
symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
387
% 'needs_format_conversion(format=None)')
390
def clone(self, url, revision_id=None, force_new_repo=False,
391
preserve_stacking=False):
393
return self._real_bzrdir.clone(url, revision_id=revision_id,
394
force_new_repo=force_new_repo, preserve_stacking=preserve_stacking)
396
def _get_config(self):
397
return RemoteBzrDirConfig(self)
400
class RemoteRepositoryFormat(repository.RepositoryFormat):
401
"""Format for repositories accessed over a _SmartClient.
403
Instances of this repository are represented by RemoteRepository
406
The RemoteRepositoryFormat is parameterized during construction
407
to reflect the capabilities of the real, remote format. Specifically
408
the attributes rich_root_data and supports_tree_reference are set
409
on a per instance basis, and are not set (and should not be) at
412
:ivar _custom_format: If set, a specific concrete repository format that
413
will be used when initializing a repository with this
414
RemoteRepositoryFormat.
415
:ivar _creating_repo: If set, the repository object that this
416
RemoteRepositoryFormat was created for: it can be called into
417
to obtain data like the network name.
420
_matchingbzrdir = RemoteBzrDirFormat()
423
repository.RepositoryFormat.__init__(self)
424
self._custom_format = None
425
self._network_name = None
426
self._creating_bzrdir = None
427
self._supports_external_lookups = None
428
self._supports_tree_reference = None
429
self._rich_root_data = None
432
def fast_deltas(self):
434
return self._custom_format.fast_deltas
437
def rich_root_data(self):
438
if self._rich_root_data is None:
440
self._rich_root_data = self._custom_format.rich_root_data
441
return self._rich_root_data
444
def supports_external_lookups(self):
445
if self._supports_external_lookups is None:
447
self._supports_external_lookups = \
448
self._custom_format.supports_external_lookups
449
return self._supports_external_lookups
452
def supports_tree_reference(self):
453
if self._supports_tree_reference is None:
455
self._supports_tree_reference = \
456
self._custom_format.supports_tree_reference
457
return self._supports_tree_reference
459
def _vfs_initialize(self, a_bzrdir, shared):
460
"""Helper for common code in initialize."""
461
if self._custom_format:
462
# Custom format requested
463
result = self._custom_format.initialize(a_bzrdir, shared=shared)
464
elif self._creating_bzrdir is not None:
465
# Use the format that the repository we were created to back
467
prior_repo = self._creating_bzrdir.open_repository()
468
prior_repo._ensure_real()
469
result = prior_repo._real_repository._format.initialize(
470
a_bzrdir, shared=shared)
472
# assume that a_bzr is a RemoteBzrDir but the smart server didn't
473
# support remote initialization.
474
# We delegate to a real object at this point (as RemoteBzrDir
475
# delegate to the repository format which would lead to infinite
476
# recursion if we just called a_bzrdir.create_repository.
477
a_bzrdir._ensure_real()
478
result = a_bzrdir._real_bzrdir.create_repository(shared=shared)
479
if not isinstance(result, RemoteRepository):
480
return self.open(a_bzrdir)
484
def initialize(self, a_bzrdir, shared=False):
485
# Being asked to create on a non RemoteBzrDir:
486
if not isinstance(a_bzrdir, RemoteBzrDir):
487
return self._vfs_initialize(a_bzrdir, shared)
488
medium = a_bzrdir._client._medium
489
if medium._is_remote_before((1, 13)):
490
return self._vfs_initialize(a_bzrdir, shared)
491
# Creating on a remote bzr dir.
492
# 1) get the network name to use.
493
if self._custom_format:
494
network_name = self._custom_format.network_name()
495
elif self._network_name:
496
network_name = self._network_name
498
# Select the current bzrlib default and ask for that.
499
reference_bzrdir_format = bzrdir.format_registry.get('default')()
500
reference_format = reference_bzrdir_format.repository_format
501
network_name = reference_format.network_name()
502
# 2) try direct creation via RPC
503
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
504
verb = 'BzrDir.create_repository'
510
response = a_bzrdir._call(verb, path, network_name, shared_str)
511
except errors.UnknownSmartMethod:
512
# Fallback - use vfs methods
513
medium._remember_remote_is_before((1, 13))
514
return self._vfs_initialize(a_bzrdir, shared)
516
# Turn the response into a RemoteRepository object.
517
format = response_tuple_to_repo_format(response[1:])
518
# Used to support creating a real format instance when needed.
519
format._creating_bzrdir = a_bzrdir
520
remote_repo = RemoteRepository(a_bzrdir, format)
521
format._creating_repo = remote_repo
524
def open(self, a_bzrdir):
525
if not isinstance(a_bzrdir, RemoteBzrDir):
526
raise AssertionError('%r is not a RemoteBzrDir' % (a_bzrdir,))
527
return a_bzrdir.open_repository()
529
def _ensure_real(self):
530
if self._custom_format is None:
531
self._custom_format = repository.network_format_registry.get(
535
def _fetch_order(self):
537
return self._custom_format._fetch_order
540
def _fetch_uses_deltas(self):
542
return self._custom_format._fetch_uses_deltas
545
def _fetch_reconcile(self):
547
return self._custom_format._fetch_reconcile
549
def get_format_description(self):
550
return 'bzr remote repository'
552
def __eq__(self, other):
553
return self.__class__ is other.__class__
555
def check_conversion_target(self, target_format):
556
if self.rich_root_data and not target_format.rich_root_data:
557
raise errors.BadConversionTarget(
558
'Does not support rich root data.', target_format)
559
if (self.supports_tree_reference and
560
not getattr(target_format, 'supports_tree_reference', False)):
561
raise errors.BadConversionTarget(
562
'Does not support nested trees', target_format)
564
def network_name(self):
565
if self._network_name:
566
return self._network_name
567
self._creating_repo._ensure_real()
568
return self._creating_repo._real_repository._format.network_name()
571
def _serializer(self):
573
return self._custom_format._serializer
576
class RemoteRepository(_RpcHelper):
577
"""Repository accessed over rpc.
579
For the moment most operations are performed using local transport-backed
583
def __init__(self, remote_bzrdir, format, real_repository=None, _client=None):
584
"""Create a RemoteRepository instance.
586
:param remote_bzrdir: The bzrdir hosting this repository.
587
:param format: The RemoteFormat object to use.
588
:param real_repository: If not None, a local implementation of the
589
repository logic for the repository, usually accessing the data
591
:param _client: Private testing parameter - override the smart client
592
to be used by the repository.
595
self._real_repository = real_repository
597
self._real_repository = None
598
self.bzrdir = remote_bzrdir
600
self._client = remote_bzrdir._client
602
self._client = _client
603
self._format = format
604
self._lock_mode = None
605
self._lock_token = None
607
self._leave_lock = False
608
# Cache of revision parents; misses are cached during read locks, and
609
# write locks when no _real_repository has been set.
610
self._unstacked_provider = graph.CachingParentsProvider(
611
get_parent_map=self._get_parent_map_rpc)
612
self._unstacked_provider.disable_cache()
614
# These depend on the actual remote format, so force them off for
615
# maximum compatibility. XXX: In future these should depend on the
616
# remote repository instance, but this is irrelevant until we perform
617
# reconcile via an RPC call.
618
self._reconcile_does_inventory_gc = False
619
self._reconcile_fixes_text_parents = False
620
self._reconcile_backsup_inventory = False
621
self.base = self.bzrdir.transport.base
622
# Additional places to query for data.
623
self._fallback_repositories = []
626
return "%s(%s)" % (self.__class__.__name__, self.base)
630
def abort_write_group(self, suppress_errors=False):
631
"""Complete a write group on the decorated repository.
633
Smart methods perform operations in a single step so this API
634
is not really applicable except as a compatibility thunk
635
for older plugins that don't use e.g. the CommitBuilder
638
:param suppress_errors: see Repository.abort_write_group.
641
return self._real_repository.abort_write_group(
642
suppress_errors=suppress_errors)
646
"""Decorate the real repository for now.
648
In the long term a full blown network facility is needed to avoid
649
creating a real repository object locally.
652
return self._real_repository.chk_bytes
654
def commit_write_group(self):
655
"""Complete a write group on the decorated repository.
657
Smart methods perform operations in a single step so this API
658
is not really applicable except as a compatibility thunk
659
for older plugins that don't use e.g. the CommitBuilder
663
return self._real_repository.commit_write_group()
665
def resume_write_group(self, tokens):
667
return self._real_repository.resume_write_group(tokens)
669
def suspend_write_group(self):
671
return self._real_repository.suspend_write_group()
673
def get_missing_parent_inventories(self):
675
return self._real_repository.get_missing_parent_inventories()
677
def _ensure_real(self):
678
"""Ensure that there is a _real_repository set.
680
Used before calls to self._real_repository.
682
Note that _ensure_real causes many roundtrips to the server which are
683
not desirable, and prevents the use of smart one-roundtrip RPC's to
684
perform complex operations (such as accessing parent data, streaming
685
revisions etc). Adding calls to _ensure_real should only be done when
686
bringing up new functionality, adding fallbacks for smart methods that
687
require a fallback path, and never to replace an existing smart method
688
invocation. If in doubt chat to the bzr network team.
690
if self._real_repository is None:
691
if 'hpss' in debug.debug_flags:
693
warning('VFS Repository access triggered\n%s',
694
''.join(traceback.format_stack()))
695
self._unstacked_provider.missing_keys.clear()
696
self.bzrdir._ensure_real()
697
self._set_real_repository(
698
self.bzrdir._real_bzrdir.open_repository())
700
def _translate_error(self, err, **context):
701
self.bzrdir._translate_error(err, repository=self, **context)
703
def find_text_key_references(self):
704
"""Find the text key references within the repository.
706
:return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
707
revision_ids. Each altered file-ids has the exact revision_ids that
708
altered it listed explicitly.
709
:return: A dictionary mapping text keys ((fileid, revision_id) tuples)
710
to whether they were referred to by the inventory of the
711
revision_id that they contain. The inventory texts from all present
712
revision ids are assessed to generate this report.
715
return self._real_repository.find_text_key_references()
717
def _generate_text_key_index(self):
718
"""Generate a new text key index for the repository.
720
This is an expensive function that will take considerable time to run.
722
:return: A dict mapping (file_id, revision_id) tuples to a list of
723
parents, also (file_id, revision_id) tuples.
726
return self._real_repository._generate_text_key_index()
728
def _get_revision_graph(self, revision_id):
729
"""Private method for using with old (< 1.2) servers to fallback."""
730
if revision_id is None:
732
elif revision.is_null(revision_id):
735
path = self.bzrdir._path_for_remote_call(self._client)
736
response = self._call_expecting_body(
737
'Repository.get_revision_graph', path, revision_id)
738
response_tuple, response_handler = response
739
if response_tuple[0] != 'ok':
740
raise errors.UnexpectedSmartServerResponse(response_tuple)
741
coded = response_handler.read_body_bytes()
743
# no revisions in this repository!
745
lines = coded.split('\n')
748
d = tuple(line.split())
749
revision_graph[d[0]] = d[1:]
751
return revision_graph
754
"""See Repository._get_sink()."""
755
return RemoteStreamSink(self)
757
def _get_source(self, to_format):
758
"""Return a source for streaming from this repository."""
759
return RemoteStreamSource(self, to_format)
762
def has_revision(self, revision_id):
763
"""True if this repository has a copy of the revision."""
764
# Copy of bzrlib.repository.Repository.has_revision
765
return revision_id in self.has_revisions((revision_id,))
768
def has_revisions(self, revision_ids):
769
"""Probe to find out the presence of multiple revisions.
771
:param revision_ids: An iterable of revision_ids.
772
:return: A set of the revision_ids that were present.
774
# Copy of bzrlib.repository.Repository.has_revisions
775
parent_map = self.get_parent_map(revision_ids)
776
result = set(parent_map)
777
if _mod_revision.NULL_REVISION in revision_ids:
778
result.add(_mod_revision.NULL_REVISION)
781
def has_same_location(self, other):
782
return (self.__class__ is other.__class__ and
783
self.bzrdir.transport.base == other.bzrdir.transport.base)
785
def get_graph(self, other_repository=None):
786
"""Return the graph for this repository format"""
787
parents_provider = self._make_parents_provider(other_repository)
788
return graph.Graph(parents_provider)
790
def gather_stats(self, revid=None, committers=None):
791
"""See Repository.gather_stats()."""
792
path = self.bzrdir._path_for_remote_call(self._client)
793
# revid can be None to indicate no revisions, not just NULL_REVISION
794
if revid is None or revision.is_null(revid):
798
if committers is None or not committers:
799
fmt_committers = 'no'
801
fmt_committers = 'yes'
802
response_tuple, response_handler = self._call_expecting_body(
803
'Repository.gather_stats', path, fmt_revid, fmt_committers)
804
if response_tuple[0] != 'ok':
805
raise errors.UnexpectedSmartServerResponse(response_tuple)
807
body = response_handler.read_body_bytes()
809
for line in body.split('\n'):
812
key, val_text = line.split(':')
813
if key in ('revisions', 'size', 'committers'):
814
result[key] = int(val_text)
815
elif key in ('firstrev', 'latestrev'):
816
values = val_text.split(' ')[1:]
817
result[key] = (float(values[0]), long(values[1]))
821
def find_branches(self, using=False):
822
"""See Repository.find_branches()."""
823
# should be an API call to the server.
825
return self._real_repository.find_branches(using=using)
827
def get_physical_lock_status(self):
828
"""See Repository.get_physical_lock_status()."""
829
# should be an API call to the server.
831
return self._real_repository.get_physical_lock_status()
833
def is_in_write_group(self):
834
"""Return True if there is an open write group.
836
write groups are only applicable locally for the smart server..
838
if self._real_repository:
839
return self._real_repository.is_in_write_group()
842
return self._lock_count >= 1
845
"""See Repository.is_shared()."""
846
path = self.bzrdir._path_for_remote_call(self._client)
847
response = self._call('Repository.is_shared', path)
848
if response[0] not in ('yes', 'no'):
849
raise SmartProtocolError('unexpected response code %s' % (response,))
850
return response[0] == 'yes'
852
def is_write_locked(self):
853
return self._lock_mode == 'w'
856
# wrong eventually - want a local lock cache context
857
if not self._lock_mode:
858
self._lock_mode = 'r'
860
self._unstacked_provider.enable_cache(cache_misses=True)
861
if self._real_repository is not None:
862
self._real_repository.lock_read()
864
self._lock_count += 1
865
for repo in self._fallback_repositories:
868
def _remote_lock_write(self, token):
869
path = self.bzrdir._path_for_remote_call(self._client)
872
err_context = {'token': token}
873
response = self._call('Repository.lock_write', path, token,
875
if response[0] == 'ok':
879
raise errors.UnexpectedSmartServerResponse(response)
881
def lock_write(self, token=None, _skip_rpc=False):
882
if not self._lock_mode:
884
if self._lock_token is not None:
885
if token != self._lock_token:
886
raise errors.TokenMismatch(token, self._lock_token)
887
self._lock_token = token
889
self._lock_token = self._remote_lock_write(token)
890
# if self._lock_token is None, then this is something like packs or
891
# svn where we don't get to lock the repo, or a weave style repository
892
# where we cannot lock it over the wire and attempts to do so will
894
if self._real_repository is not None:
895
self._real_repository.lock_write(token=self._lock_token)
896
if token is not None:
897
self._leave_lock = True
899
self._leave_lock = False
900
self._lock_mode = 'w'
902
cache_misses = self._real_repository is None
903
self._unstacked_provider.enable_cache(cache_misses=cache_misses)
904
elif self._lock_mode == 'r':
905
raise errors.ReadOnlyError(self)
907
self._lock_count += 1
908
for repo in self._fallback_repositories:
909
# Writes don't affect fallback repos
911
return self._lock_token or None
913
def leave_lock_in_place(self):
914
if not self._lock_token:
915
raise NotImplementedError(self.leave_lock_in_place)
916
self._leave_lock = True
918
def dont_leave_lock_in_place(self):
919
if not self._lock_token:
920
raise NotImplementedError(self.dont_leave_lock_in_place)
921
self._leave_lock = False
923
def _set_real_repository(self, repository):
924
"""Set the _real_repository for this repository.
926
:param repository: The repository to fallback to for non-hpss
927
implemented operations.
929
if self._real_repository is not None:
930
# Replacing an already set real repository.
931
# We cannot do this [currently] if the repository is locked -
932
# synchronised state might be lost.
934
raise AssertionError('_real_repository is already set')
935
if isinstance(repository, RemoteRepository):
936
raise AssertionError()
937
self._real_repository = repository
938
# three code paths happen here:
939
# 1) old servers, RemoteBranch.open() calls _ensure_real before setting
940
# up stacking. In this case self._fallback_repositories is [], and the
941
# real repo is already setup. Preserve the real repo and
942
# RemoteRepository.add_fallback_repository will avoid adding
944
# 2) new servers, RemoteBranch.open() sets up stacking, and when
945
# ensure_real is triggered from a branch, the real repository to
946
# set already has a matching list with separate instances, but
947
# as they are also RemoteRepositories we don't worry about making the
948
# lists be identical.
949
# 3) new servers, RemoteRepository.ensure_real is triggered before
950
# RemoteBranch.ensure real, in this case we get a repo with no fallbacks
951
# and need to populate it.
952
if (self._fallback_repositories and
953
len(self._real_repository._fallback_repositories) !=
954
len(self._fallback_repositories)):
955
if len(self._real_repository._fallback_repositories):
956
raise AssertionError(
957
"cannot cleanly remove existing _fallback_repositories")
958
for fb in self._fallback_repositories:
959
self._real_repository.add_fallback_repository(fb)
960
if self._lock_mode == 'w':
961
# if we are already locked, the real repository must be able to
962
# acquire the lock with our token.
963
self._real_repository.lock_write(self._lock_token)
964
elif self._lock_mode == 'r':
965
self._real_repository.lock_read()
967
def start_write_group(self):
968
"""Start a write group on the decorated repository.
970
Smart methods perform operations in a single step so this API
971
is not really applicable except as a compatibility thunk
972
for older plugins that don't use e.g. the CommitBuilder
976
return self._real_repository.start_write_group()
978
def _unlock(self, token):
979
path = self.bzrdir._path_for_remote_call(self._client)
981
# with no token the remote repository is not persistently locked.
983
err_context = {'token': token}
984
response = self._call('Repository.unlock', path, token,
986
if response == ('ok',):
989
raise errors.UnexpectedSmartServerResponse(response)
992
if not self._lock_count:
993
raise errors.LockNotHeld(self)
994
self._lock_count -= 1
995
if self._lock_count > 0:
997
self._unstacked_provider.disable_cache()
998
old_mode = self._lock_mode
999
self._lock_mode = None
1001
# The real repository is responsible at present for raising an
1002
# exception if it's in an unfinished write group. However, it
1003
# normally will *not* actually remove the lock from disk - that's
1004
# done by the server on receiving the Repository.unlock call.
1005
# This is just to let the _real_repository stay up to date.
1006
if self._real_repository is not None:
1007
self._real_repository.unlock()
1009
# The rpc-level lock should be released even if there was a
1010
# problem releasing the vfs-based lock.
1012
# Only write-locked repositories need to make a remote method
1013
# call to perform the unlock.
1014
old_token = self._lock_token
1015
self._lock_token = None
1016
if not self._leave_lock:
1017
self._unlock(old_token)
1019
def break_lock(self):
1020
# should hand off to the network
1022
return self._real_repository.break_lock()
1024
def _get_tarball(self, compression):
1025
"""Return a TemporaryFile containing a repository tarball.
1027
Returns None if the server does not support sending tarballs.
1030
path = self.bzrdir._path_for_remote_call(self._client)
1032
response, protocol = self._call_expecting_body(
1033
'Repository.tarball', path, compression)
1034
except errors.UnknownSmartMethod:
1035
protocol.cancel_read_body()
1037
if response[0] == 'ok':
1038
# Extract the tarball and return it
1039
t = tempfile.NamedTemporaryFile()
1040
# TODO: rpc layer should read directly into it...
1041
t.write(protocol.read_body_bytes())
1044
raise errors.UnexpectedSmartServerResponse(response)
1046
def sprout(self, to_bzrdir, revision_id=None):
1047
# TODO: Option to control what format is created?
1049
dest_repo = self._real_repository._format.initialize(to_bzrdir,
1051
dest_repo.fetch(self, revision_id=revision_id)
1054
### These methods are just thin shims to the VFS object for now.
1056
def revision_tree(self, revision_id):
1058
return self._real_repository.revision_tree(revision_id)
1060
def get_serializer_format(self):
1062
return self._real_repository.get_serializer_format()
1064
def get_commit_builder(self, branch, parents, config, timestamp=None,
1065
timezone=None, committer=None, revprops=None,
1067
# FIXME: It ought to be possible to call this without immediately
1068
# triggering _ensure_real. For now it's the easiest thing to do.
1070
real_repo = self._real_repository
1071
builder = real_repo.get_commit_builder(branch, parents,
1072
config, timestamp=timestamp, timezone=timezone,
1073
committer=committer, revprops=revprops, revision_id=revision_id)
1076
def add_fallback_repository(self, repository):
1077
"""Add a repository to use for looking up data not held locally.
1079
:param repository: A repository.
1081
if not self._format.supports_external_lookups:
1082
raise errors.UnstackableRepositoryFormat(
1083
self._format.network_name(), self.base)
1084
# We need to accumulate additional repositories here, to pass them in
1087
self._fallback_repositories.append(repository)
1088
# If self._real_repository was parameterised already (e.g. because a
1089
# _real_branch had its get_stacked_on_url method called), then the
1090
# repository to be added may already be in the _real_repositories list.
1091
if self._real_repository is not None:
1092
fallback_locations = [repo.bzrdir.root_transport.base for repo in
1093
self._real_repository._fallback_repositories]
1094
if repository.bzrdir.root_transport.base not in fallback_locations:
1095
self._real_repository.add_fallback_repository(repository)
1097
def add_inventory(self, revid, inv, parents):
1099
return self._real_repository.add_inventory(revid, inv, parents)
1101
def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1104
return self._real_repository.add_inventory_by_delta(basis_revision_id,
1105
delta, new_revision_id, parents)
1107
def add_revision(self, rev_id, rev, inv=None, config=None):
1109
return self._real_repository.add_revision(
1110
rev_id, rev, inv=inv, config=config)
1113
def get_inventory(self, revision_id):
1115
return self._real_repository.get_inventory(revision_id)
1117
def iter_inventories(self, revision_ids):
1119
return self._real_repository.iter_inventories(revision_ids)
1122
def get_revision(self, revision_id):
1124
return self._real_repository.get_revision(revision_id)
1126
def get_transaction(self):
1128
return self._real_repository.get_transaction()
1131
def clone(self, a_bzrdir, revision_id=None):
1133
return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
1135
def make_working_trees(self):
1136
"""See Repository.make_working_trees"""
1138
return self._real_repository.make_working_trees()
1140
def refresh_data(self):
1141
"""Re-read any data needed to to synchronise with disk.
1143
This method is intended to be called after another repository instance
1144
(such as one used by a smart server) has inserted data into the
1145
repository. It may not be called during a write group, but may be
1146
called at any other time.
1148
if self.is_in_write_group():
1149
raise errors.InternalBzrError(
1150
"May not refresh_data while in a write group.")
1151
if self._real_repository is not None:
1152
self._real_repository.refresh_data()
1154
def revision_ids_to_search_result(self, result_set):
1155
"""Convert a set of revision ids to a graph SearchResult."""
1156
result_parents = set()
1157
for parents in self.get_graph().get_parent_map(
1158
result_set).itervalues():
1159
result_parents.update(parents)
1160
included_keys = result_set.intersection(result_parents)
1161
start_keys = result_set.difference(included_keys)
1162
exclude_keys = result_parents.difference(result_set)
1163
result = graph.SearchResult(start_keys, exclude_keys,
1164
len(result_set), result_set)
1168
def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1169
"""Return the revision ids that other has that this does not.
1171
These are returned in topological order.
1173
revision_id: only return revision ids included by revision_id.
1175
return repository.InterRepository.get(
1176
other, self).search_missing_revision_ids(revision_id, find_ghosts)
1178
def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
1180
# No base implementation to use as RemoteRepository is not a subclass
1181
# of Repository; so this is a copy of Repository.fetch().
1182
if fetch_spec is not None and revision_id is not None:
1183
raise AssertionError(
1184
"fetch_spec and revision_id are mutually exclusive.")
1185
if self.is_in_write_group():
1186
raise errors.InternalBzrError(
1187
"May not fetch while in a write group.")
1188
# fast path same-url fetch operations
1189
if self.has_same_location(source) and fetch_spec is None:
1190
# check that last_revision is in 'from' and then return a
1192
if (revision_id is not None and
1193
not revision.is_null(revision_id)):
1194
self.get_revision(revision_id)
1196
# if there is no specific appropriate InterRepository, this will get
1197
# the InterRepository base class, which raises an
1198
# IncompatibleRepositories when asked to fetch.
1199
inter = repository.InterRepository.get(source, self)
1200
return inter.fetch(revision_id=revision_id, pb=pb,
1201
find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1203
def create_bundle(self, target, base, fileobj, format=None):
1205
self._real_repository.create_bundle(target, base, fileobj, format)
1208
def get_ancestry(self, revision_id, topo_sorted=True):
1210
return self._real_repository.get_ancestry(revision_id, topo_sorted)
1212
def fileids_altered_by_revision_ids(self, revision_ids):
1214
return self._real_repository.fileids_altered_by_revision_ids(revision_ids)
1216
def _get_versioned_file_checker(self, revisions, revision_versions_cache):
1218
return self._real_repository._get_versioned_file_checker(
1219
revisions, revision_versions_cache)
1221
def iter_files_bytes(self, desired_files):
1222
"""See Repository.iter_file_bytes.
1225
return self._real_repository.iter_files_bytes(desired_files)
1227
def get_parent_map(self, revision_ids):
1228
"""See bzrlib.Graph.get_parent_map()."""
1229
return self._make_parents_provider().get_parent_map(revision_ids)
1231
def _get_parent_map_rpc(self, keys):
1232
"""Helper for get_parent_map that performs the RPC."""
1233
medium = self._client._medium
1234
if medium._is_remote_before((1, 2)):
1235
# We already found out that the server can't understand
1236
# Repository.get_parent_map requests, so just fetch the whole
1239
# Note that this reads the whole graph, when only some keys are
1240
# wanted. On this old server there's no way (?) to get them all
1241
# in one go, and the user probably will have seen a warning about
1242
# the server being old anyhow.
1243
rg = self._get_revision_graph(None)
1244
# There is an API discrepancy between get_parent_map and
1245
# get_revision_graph. Specifically, a "key:()" pair in
1246
# get_revision_graph just means a node has no parents. For
1247
# "get_parent_map" it means the node is a ghost. So fix up the
1248
# graph to correct this.
1249
# https://bugs.launchpad.net/bzr/+bug/214894
1250
# There is one other "bug" which is that ghosts in
1251
# get_revision_graph() are not returned at all. But we won't worry
1252
# about that for now.
1253
for node_id, parent_ids in rg.iteritems():
1254
if parent_ids == ():
1255
rg[node_id] = (NULL_REVISION,)
1256
rg[NULL_REVISION] = ()
1261
raise ValueError('get_parent_map(None) is not valid')
1262
if NULL_REVISION in keys:
1263
keys.discard(NULL_REVISION)
1264
found_parents = {NULL_REVISION:()}
1266
return found_parents
1269
# TODO(Needs analysis): We could assume that the keys being requested
1270
# from get_parent_map are in a breadth first search, so typically they
1271
# will all be depth N from some common parent, and we don't have to
1272
# have the server iterate from the root parent, but rather from the
1273
# keys we're searching; and just tell the server the keyspace we
1274
# already have; but this may be more traffic again.
1276
# Transform self._parents_map into a search request recipe.
1277
# TODO: Manage this incrementally to avoid covering the same path
1278
# repeatedly. (The server will have to on each request, but the less
1279
# work done the better).
1281
# Negative caching notes:
1282
# new server sends missing when a request including the revid
1283
# 'include-missing:' is present in the request.
1284
# missing keys are serialised as missing:X, and we then call
1285
# provider.note_missing(X) for-all X
1286
parents_map = self._unstacked_provider.get_cached_map()
1287
if parents_map is None:
1288
# Repository is not locked, so there's no cache.
1290
# start_set is all the keys in the cache
1291
start_set = set(parents_map)
1292
# result set is all the references to keys in the cache
1293
result_parents = set()
1294
for parents in parents_map.itervalues():
1295
result_parents.update(parents)
1296
stop_keys = result_parents.difference(start_set)
1297
# We don't need to send ghosts back to the server as a position to
1299
stop_keys.difference_update(self._unstacked_provider.missing_keys)
1300
key_count = len(parents_map)
1301
if (NULL_REVISION in result_parents
1302
and NULL_REVISION in self._unstacked_provider.missing_keys):
1303
# If we pruned NULL_REVISION from the stop_keys because it's also
1304
# in our cache of "missing" keys we need to increment our key count
1305
# by 1, because the reconsitituted SearchResult on the server will
1306
# still consider NULL_REVISION to be an included key.
1308
included_keys = start_set.intersection(result_parents)
1309
start_set.difference_update(included_keys)
1310
recipe = ('manual', start_set, stop_keys, key_count)
1311
body = self._serialise_search_recipe(recipe)
1312
path = self.bzrdir._path_for_remote_call(self._client)
1314
if type(key) is not str:
1316
"key %r not a plain string" % (key,))
1317
verb = 'Repository.get_parent_map'
1318
args = (path, 'include-missing:') + tuple(keys)
1320
response = self._call_with_body_bytes_expecting_body(
1322
except errors.UnknownSmartMethod:
1323
# Server does not support this method, so get the whole graph.
1324
# Worse, we have to force a disconnection, because the server now
1325
# doesn't realise it has a body on the wire to consume, so the
1326
# only way to recover is to abandon the connection.
1328
'Server is too old for fast get_parent_map, reconnecting. '
1329
'(Upgrade the server to Bazaar 1.2 to avoid this)')
1331
# To avoid having to disconnect repeatedly, we keep track of the
1332
# fact the server doesn't understand remote methods added in 1.2.
1333
medium._remember_remote_is_before((1, 2))
1334
# Recurse just once and we should use the fallback code.
1335
return self._get_parent_map_rpc(keys)
1336
response_tuple, response_handler = response
1337
if response_tuple[0] not in ['ok']:
1338
response_handler.cancel_read_body()
1339
raise errors.UnexpectedSmartServerResponse(response_tuple)
1340
if response_tuple[0] == 'ok':
1341
coded = bz2.decompress(response_handler.read_body_bytes())
1343
# no revisions found
1345
lines = coded.split('\n')
1348
d = tuple(line.split())
1350
revision_graph[d[0]] = d[1:]
1353
if d[0].startswith('missing:'):
1355
self._unstacked_provider.note_missing_key(revid)
1357
# no parents - so give the Graph result
1359
revision_graph[d[0]] = (NULL_REVISION,)
1360
return revision_graph
1363
def get_signature_text(self, revision_id):
1365
return self._real_repository.get_signature_text(revision_id)
1368
def get_inventory_xml(self, revision_id):
1370
return self._real_repository.get_inventory_xml(revision_id)
1372
def deserialise_inventory(self, revision_id, xml):
1374
return self._real_repository.deserialise_inventory(revision_id, xml)
1376
def reconcile(self, other=None, thorough=False):
1378
return self._real_repository.reconcile(other=other, thorough=thorough)
1380
def all_revision_ids(self):
1382
return self._real_repository.all_revision_ids()
1385
def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1387
return self._real_repository.get_deltas_for_revisions(revisions,
1388
specific_fileids=specific_fileids)
1391
def get_revision_delta(self, revision_id, specific_fileids=None):
1393
return self._real_repository.get_revision_delta(revision_id,
1394
specific_fileids=specific_fileids)
1397
def revision_trees(self, revision_ids):
1399
return self._real_repository.revision_trees(revision_ids)
1402
def get_revision_reconcile(self, revision_id):
1404
return self._real_repository.get_revision_reconcile(revision_id)
1407
def check(self, revision_ids=None):
1409
return self._real_repository.check(revision_ids=revision_ids)
1411
def copy_content_into(self, destination, revision_id=None):
1413
return self._real_repository.copy_content_into(
1414
destination, revision_id=revision_id)
1416
def _copy_repository_tarball(self, to_bzrdir, revision_id=None):
1417
# get a tarball of the remote repository, and copy from that into the
1419
from bzrlib import osutils
1421
# TODO: Maybe a progress bar while streaming the tarball?
1422
note("Copying repository content as tarball...")
1423
tar_file = self._get_tarball('bz2')
1424
if tar_file is None:
1426
destination = to_bzrdir.create_repository()
1428
tar = tarfile.open('repository', fileobj=tar_file,
1430
tmpdir = osutils.mkdtemp()
1432
_extract_tar(tar, tmpdir)
1433
tmp_bzrdir = BzrDir.open(tmpdir)
1434
tmp_repo = tmp_bzrdir.open_repository()
1435
tmp_repo.copy_content_into(destination, revision_id)
1437
osutils.rmtree(tmpdir)
1441
# TODO: Suggestion from john: using external tar is much faster than
1442
# python's tarfile library, but it may not work on windows.
1445
def inventories(self):
1446
"""Decorate the real repository for now.
1448
In the long term a full blown network facility is needed to
1449
avoid creating a real repository object locally.
1452
return self._real_repository.inventories
1456
"""Compress the data within the repository.
1458
This is not currently implemented within the smart server.
1461
return self._real_repository.pack()
1464
def revisions(self):
1465
"""Decorate the real repository for now.
1467
In the short term this should become a real object to intercept graph
1470
In the long term a full blown network facility is needed.
1473
return self._real_repository.revisions
1475
def set_make_working_trees(self, new_value):
1477
new_value_str = "True"
1479
new_value_str = "False"
1480
path = self.bzrdir._path_for_remote_call(self._client)
1482
response = self._call(
1483
'Repository.set_make_working_trees', path, new_value_str)
1484
except errors.UnknownSmartMethod:
1486
self._real_repository.set_make_working_trees(new_value)
1488
if response[0] != 'ok':
1489
raise errors.UnexpectedSmartServerResponse(response)
1492
def signatures(self):
1493
"""Decorate the real repository for now.
1495
In the long term a full blown network facility is needed to avoid
1496
creating a real repository object locally.
1499
return self._real_repository.signatures
1502
def sign_revision(self, revision_id, gpg_strategy):
1504
return self._real_repository.sign_revision(revision_id, gpg_strategy)
1508
"""Decorate the real repository for now.
1510
In the long term a full blown network facility is needed to avoid
1511
creating a real repository object locally.
1514
return self._real_repository.texts
1517
def get_revisions(self, revision_ids):
1519
return self._real_repository.get_revisions(revision_ids)
1521
def supports_rich_root(self):
1522
return self._format.rich_root_data
1524
def iter_reverse_revision_history(self, revision_id):
1526
return self._real_repository.iter_reverse_revision_history(revision_id)
1529
def _serializer(self):
1530
return self._format._serializer
1532
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1534
return self._real_repository.store_revision_signature(
1535
gpg_strategy, plaintext, revision_id)
1537
def add_signature_text(self, revision_id, signature):
1539
return self._real_repository.add_signature_text(revision_id, signature)
1541
def has_signature_for_revision_id(self, revision_id):
1543
return self._real_repository.has_signature_for_revision_id(revision_id)
1545
def item_keys_introduced_by(self, revision_ids, _files_pb=None):
1547
return self._real_repository.item_keys_introduced_by(revision_ids,
1548
_files_pb=_files_pb)
1550
def revision_graph_can_have_wrong_parents(self):
1551
# The answer depends on the remote repo format.
1553
return self._real_repository.revision_graph_can_have_wrong_parents()
1555
def _find_inconsistent_revision_parents(self):
1557
return self._real_repository._find_inconsistent_revision_parents()
1559
def _check_for_inconsistent_revision_parents(self):
1561
return self._real_repository._check_for_inconsistent_revision_parents()
1563
def _make_parents_provider(self, other=None):
1564
providers = [self._unstacked_provider]
1565
if other is not None:
1566
providers.insert(0, other)
1567
providers.extend(r._make_parents_provider() for r in
1568
self._fallback_repositories)
1569
return graph._StackedParentsProvider(providers)
1571
def _serialise_search_recipe(self, recipe):
1572
"""Serialise a graph search recipe.
1574
:param recipe: A search recipe (start, stop, count).
1575
:return: Serialised bytes.
1577
start_keys = ' '.join(recipe[1])
1578
stop_keys = ' '.join(recipe[2])
1579
count = str(recipe[3])
1580
return '\n'.join((start_keys, stop_keys, count))
1582
def _serialise_search_result(self, search_result):
1583
if isinstance(search_result, graph.PendingAncestryResult):
1584
parts = ['ancestry-of']
1585
parts.extend(search_result.heads)
1587
recipe = search_result.get_recipe()
1588
parts = [recipe[0], self._serialise_search_recipe(recipe)]
1589
return '\n'.join(parts)
1592
path = self.bzrdir._path_for_remote_call(self._client)
1594
response = self._call('PackRepository.autopack', path)
1595
except errors.UnknownSmartMethod:
1597
self._real_repository._pack_collection.autopack()
1600
if response[0] != 'ok':
1601
raise errors.UnexpectedSmartServerResponse(response)
1604
class RemoteStreamSink(repository.StreamSink):
1606
def _insert_real(self, stream, src_format, resume_tokens):
1607
self.target_repo._ensure_real()
1608
sink = self.target_repo._real_repository._get_sink()
1609
result = sink.insert_stream(stream, src_format, resume_tokens)
1611
self.target_repo.autopack()
1614
def insert_stream(self, stream, src_format, resume_tokens):
1615
target = self.target_repo
1616
target._unstacked_provider.missing_keys.clear()
1617
if target._lock_token:
1618
verb = 'Repository.insert_stream_locked'
1619
extra_args = (target._lock_token or '',)
1620
required_version = (1, 14)
1622
verb = 'Repository.insert_stream'
1624
required_version = (1, 13)
1625
client = target._client
1626
medium = client._medium
1627
if medium._is_remote_before(required_version):
1628
# No possible way this can work.
1629
return self._insert_real(stream, src_format, resume_tokens)
1630
path = target.bzrdir._path_for_remote_call(client)
1631
if not resume_tokens:
1632
# XXX: Ugly but important for correctness, *will* be fixed during
1633
# 1.13 cycle. Pushing a stream that is interrupted results in a
1634
# fallback to the _real_repositories sink *with a partial stream*.
1635
# Thats bad because we insert less data than bzr expected. To avoid
1636
# this we do a trial push to make sure the verb is accessible, and
1637
# do not fallback when actually pushing the stream. A cleanup patch
1638
# is going to look at rewinding/restarting the stream/partial
1640
byte_stream = smart_repo._stream_to_byte_stream([], src_format)
1642
response = client.call_with_body_stream(
1643
(verb, path, '') + extra_args, byte_stream)
1644
except errors.UnknownSmartMethod:
1645
medium._remember_remote_is_before(required_version)
1646
return self._insert_real(stream, src_format, resume_tokens)
1647
byte_stream = smart_repo._stream_to_byte_stream(
1649
resume_tokens = ' '.join(resume_tokens)
1650
response = client.call_with_body_stream(
1651
(verb, path, resume_tokens) + extra_args, byte_stream)
1652
if response[0][0] not in ('ok', 'missing-basis'):
1653
raise errors.UnexpectedSmartServerResponse(response)
1654
if response[0][0] == 'missing-basis':
1655
tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1656
resume_tokens = tokens
1657
return resume_tokens, set(missing_keys)
1659
self.target_repo.refresh_data()
1663
class RemoteStreamSource(repository.StreamSource):
1664
"""Stream data from a remote server."""
1666
def get_stream(self, search):
1667
if (self.from_repository._fallback_repositories and
1668
self.to_format._fetch_order == 'topological'):
1669
return self._real_stream(self.from_repository, search)
1670
return self.missing_parents_chain(search, [self.from_repository] +
1671
self.from_repository._fallback_repositories)
1673
def _real_stream(self, repo, search):
1674
"""Get a stream for search from repo.
1676
This never called RemoteStreamSource.get_stream, and is a heler
1677
for RemoteStreamSource._get_stream to allow getting a stream
1678
reliably whether fallback back because of old servers or trying
1679
to stream from a non-RemoteRepository (which the stacked support
1682
source = repo._get_source(self.to_format)
1683
if isinstance(source, RemoteStreamSource):
1684
return repository.StreamSource.get_stream(source, search)
1685
return source.get_stream(search)
1687
def _get_stream(self, repo, search):
1688
"""Core worker to get a stream from repo for search.
1690
This is used by both get_stream and the stacking support logic. It
1691
deliberately gets a stream for repo which does not need to be
1692
self.from_repository. In the event that repo is not Remote, or
1693
cannot do a smart stream, a fallback is made to the generic
1694
repository._get_stream() interface, via self._real_stream.
1696
In the event of stacking, streams from _get_stream will not
1697
contain all the data for search - this is normal (see get_stream).
1699
:param repo: A repository.
1700
:param search: A search.
1702
# Fallbacks may be non-smart
1703
if not isinstance(repo, RemoteRepository):
1704
return self._real_stream(repo, search)
1705
client = repo._client
1706
medium = client._medium
1707
if medium._is_remote_before((1, 13)):
1708
# streaming was added in 1.13
1709
return self._real_stream(repo, search)
1710
path = repo.bzrdir._path_for_remote_call(client)
1712
search_bytes = repo._serialise_search_result(search)
1713
response = repo._call_with_body_bytes_expecting_body(
1714
'Repository.get_stream',
1715
(path, self.to_format.network_name()), search_bytes)
1716
response_tuple, response_handler = response
1717
except errors.UnknownSmartMethod:
1718
medium._remember_remote_is_before((1,13))
1719
return self._real_stream(repo, search)
1720
if response_tuple[0] != 'ok':
1721
raise errors.UnexpectedSmartServerResponse(response_tuple)
1722
byte_stream = response_handler.read_streamed_body()
1723
src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
1724
if src_format.network_name() != repo._format.network_name():
1725
raise AssertionError(
1726
"Mismatched RemoteRepository and stream src %r, %r" % (
1727
src_format.network_name(), repo._format.network_name()))
1730
def missing_parents_chain(self, search, sources):
1731
"""Chain multiple streams together to handle stacking.
1733
:param search: The overall search to satisfy with streams.
1734
:param sources: A list of Repository objects to query.
1736
self.serialiser = self.to_format._serializer
1737
self.seen_revs = set()
1738
self.referenced_revs = set()
1739
# If there are heads in the search, or the key count is > 0, we are not
1741
while not search.is_empty() and len(sources) > 1:
1742
source = sources.pop(0)
1743
stream = self._get_stream(source, search)
1744
for kind, substream in stream:
1745
if kind != 'revisions':
1746
yield kind, substream
1748
yield kind, self.missing_parents_rev_handler(substream)
1749
search = search.refine(self.seen_revs, self.referenced_revs)
1750
self.seen_revs = set()
1751
self.referenced_revs = set()
1752
if not search.is_empty():
1753
for kind, stream in self._get_stream(sources[0], search):
1756
def missing_parents_rev_handler(self, substream):
1757
for content in substream:
1758
revision_bytes = content.get_bytes_as('fulltext')
1759
revision = self.serialiser.read_revision_from_string(revision_bytes)
1760
self.seen_revs.add(content.key[-1])
1761
self.referenced_revs.update(revision.parent_ids)
1765
class RemoteBranchLockableFiles(LockableFiles):
1766
"""A 'LockableFiles' implementation that talks to a smart server.
1768
This is not a public interface class.
1771
def __init__(self, bzrdir, _client):
1772
self.bzrdir = bzrdir
1773
self._client = _client
1774
self._need_find_modes = True
1775
LockableFiles.__init__(
1776
self, bzrdir.get_branch_transport(None),
1777
'lock', lockdir.LockDir)
1779
def _find_modes(self):
1780
# RemoteBranches don't let the client set the mode of control files.
1781
self._dir_mode = None
1782
self._file_mode = None
1785
class RemoteBranchFormat(branch.BranchFormat):
1787
def __init__(self, network_name=None):
1788
super(RemoteBranchFormat, self).__init__()
1789
self._matchingbzrdir = RemoteBzrDirFormat()
1790
self._matchingbzrdir.set_branch_format(self)
1791
self._custom_format = None
1792
self._network_name = network_name
1794
def __eq__(self, other):
1795
return (isinstance(other, RemoteBranchFormat) and
1796
self.__dict__ == other.__dict__)
1798
def _ensure_real(self):
1799
if self._custom_format is None:
1800
self._custom_format = branch.network_format_registry.get(
1803
def get_format_description(self):
1804
return 'Remote BZR Branch'
1806
def network_name(self):
1807
return self._network_name
1809
def open(self, a_bzrdir, ignore_fallbacks=False):
1810
return a_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
1812
def _vfs_initialize(self, a_bzrdir):
1813
# Initialisation when using a local bzrdir object, or a non-vfs init
1814
# method is not available on the server.
1815
# self._custom_format is always set - the start of initialize ensures
1817
if isinstance(a_bzrdir, RemoteBzrDir):
1818
a_bzrdir._ensure_real()
1819
result = self._custom_format.initialize(a_bzrdir._real_bzrdir)
1821
# We assume the bzrdir is parameterised; it may not be.
1822
result = self._custom_format.initialize(a_bzrdir)
1823
if (isinstance(a_bzrdir, RemoteBzrDir) and
1824
not isinstance(result, RemoteBranch)):
1825
result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result)
1828
def initialize(self, a_bzrdir):
1829
# 1) get the network name to use.
1830
if self._custom_format:
1831
network_name = self._custom_format.network_name()
1833
# Select the current bzrlib default and ask for that.
1834
reference_bzrdir_format = bzrdir.format_registry.get('default')()
1835
reference_format = reference_bzrdir_format.get_branch_format()
1836
self._custom_format = reference_format
1837
network_name = reference_format.network_name()
1838
# Being asked to create on a non RemoteBzrDir:
1839
if not isinstance(a_bzrdir, RemoteBzrDir):
1840
return self._vfs_initialize(a_bzrdir)
1841
medium = a_bzrdir._client._medium
1842
if medium._is_remote_before((1, 13)):
1843
return self._vfs_initialize(a_bzrdir)
1844
# Creating on a remote bzr dir.
1845
# 2) try direct creation via RPC
1846
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
1847
verb = 'BzrDir.create_branch'
1849
response = a_bzrdir._call(verb, path, network_name)
1850
except errors.UnknownSmartMethod:
1851
# Fallback - use vfs methods
1852
medium._remember_remote_is_before((1, 13))
1853
return self._vfs_initialize(a_bzrdir)
1854
if response[0] != 'ok':
1855
raise errors.UnexpectedSmartServerResponse(response)
1856
# Turn the response into a RemoteRepository object.
1857
format = RemoteBranchFormat(network_name=response[1])
1858
repo_format = response_tuple_to_repo_format(response[3:])
1859
if response[2] == '':
1860
repo_bzrdir = a_bzrdir
1862
repo_bzrdir = RemoteBzrDir(
1863
a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
1865
remote_repo = RemoteRepository(repo_bzrdir, repo_format)
1866
remote_branch = RemoteBranch(a_bzrdir, remote_repo,
1867
format=format, setup_stacking=False)
1868
# XXX: We know this is a new branch, so it must have revno 0, revid
1869
# NULL_REVISION. Creating the branch locked would make this be unable
1870
# to be wrong; here its simply very unlikely to be wrong. RBC 20090225
1871
remote_branch._last_revision_info_cache = 0, NULL_REVISION
1872
return remote_branch
1874
def make_tags(self, branch):
1876
return self._custom_format.make_tags(branch)
1878
def supports_tags(self):
1879
# Remote branches might support tags, but we won't know until we
1880
# access the real remote branch.
1882
return self._custom_format.supports_tags()
1884
def supports_stacking(self):
1886
return self._custom_format.supports_stacking()
1889
class RemoteBranch(branch.Branch, _RpcHelper):
1890
"""Branch stored on a server accessed by HPSS RPC.
1892
At the moment most operations are mapped down to simple file operations.
1895
def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
1896
_client=None, format=None, setup_stacking=True):
1897
"""Create a RemoteBranch instance.
1899
:param real_branch: An optional local implementation of the branch
1900
format, usually accessing the data via the VFS.
1901
:param _client: Private parameter for testing.
1902
:param format: A RemoteBranchFormat object, None to create one
1903
automatically. If supplied it should have a network_name already
1905
:param setup_stacking: If True make an RPC call to determine the
1906
stacked (or not) status of the branch. If False assume the branch
1909
# We intentionally don't call the parent class's __init__, because it
1910
# will try to assign to self.tags, which is a property in this subclass.
1911
# And the parent's __init__ doesn't do much anyway.
1912
self._revision_id_to_revno_cache = None
1913
self._partial_revision_id_to_revno_cache = {}
1914
self._revision_history_cache = None
1915
self._last_revision_info_cache = None
1916
self._merge_sorted_revisions_cache = None
1917
self.bzrdir = remote_bzrdir
1918
if _client is not None:
1919
self._client = _client
1921
self._client = remote_bzrdir._client
1922
self.repository = remote_repository
1923
if real_branch is not None:
1924
self._real_branch = real_branch
1925
# Give the remote repository the matching real repo.
1926
real_repo = self._real_branch.repository
1927
if isinstance(real_repo, RemoteRepository):
1928
real_repo._ensure_real()
1929
real_repo = real_repo._real_repository
1930
self.repository._set_real_repository(real_repo)
1931
# Give the branch the remote repository to let fast-pathing happen.
1932
self._real_branch.repository = self.repository
1934
self._real_branch = None
1935
# Fill out expected attributes of branch for bzrlib API users.
1936
self.base = self.bzrdir.root_transport.base
1937
self._control_files = None
1938
self._lock_mode = None
1939
self._lock_token = None
1940
self._repo_lock_token = None
1941
self._lock_count = 0
1942
self._leave_lock = False
1943
# Setup a format: note that we cannot call _ensure_real until all the
1944
# attributes above are set: This code cannot be moved higher up in this
1947
self._format = RemoteBranchFormat()
1948
if real_branch is not None:
1949
self._format._network_name = \
1950
self._real_branch._format.network_name()
1952
self._format = format
1953
if not self._format._network_name:
1954
# Did not get from open_branchV2 - old server.
1956
self._format._network_name = \
1957
self._real_branch._format.network_name()
1958
self.tags = self._format.make_tags(self)
1959
# The base class init is not called, so we duplicate this:
1960
hooks = branch.Branch.hooks['open']
1964
self._setup_stacking()
1966
def _setup_stacking(self):
1967
# configure stacking into the remote repository, by reading it from
1970
fallback_url = self.get_stacked_on_url()
1971
except (errors.NotStacked, errors.UnstackableBranchFormat,
1972
errors.UnstackableRepositoryFormat), e:
1974
self._activate_fallback_location(fallback_url, None)
1976
def _get_config(self):
1977
return RemoteBranchConfig(self)
1979
def _get_real_transport(self):
1980
# if we try vfs access, return the real branch's vfs transport
1982
return self._real_branch._transport
1984
_transport = property(_get_real_transport)
1987
return "%s(%s)" % (self.__class__.__name__, self.base)
1991
def _ensure_real(self):
1992
"""Ensure that there is a _real_branch set.
1994
Used before calls to self._real_branch.
1996
if self._real_branch is None:
1997
if not vfs.vfs_enabled():
1998
raise AssertionError('smart server vfs must be enabled '
1999
'to use vfs implementation')
2000
self.bzrdir._ensure_real()
2001
self._real_branch = self.bzrdir._real_bzrdir.open_branch()
2002
if self.repository._real_repository is None:
2003
# Give the remote repository the matching real repo.
2004
real_repo = self._real_branch.repository
2005
if isinstance(real_repo, RemoteRepository):
2006
real_repo._ensure_real()
2007
real_repo = real_repo._real_repository
2008
self.repository._set_real_repository(real_repo)
2009
# Give the real branch the remote repository to let fast-pathing
2011
self._real_branch.repository = self.repository
2012
if self._lock_mode == 'r':
2013
self._real_branch.lock_read()
2014
elif self._lock_mode == 'w':
2015
self._real_branch.lock_write(token=self._lock_token)
2017
def _translate_error(self, err, **context):
2018
self.repository._translate_error(err, branch=self, **context)
2020
def _clear_cached_state(self):
2021
super(RemoteBranch, self)._clear_cached_state()
2022
if self._real_branch is not None:
2023
self._real_branch._clear_cached_state()
2025
def _clear_cached_state_of_remote_branch_only(self):
2026
"""Like _clear_cached_state, but doesn't clear the cache of
2029
This is useful when falling back to calling a method of
2030
self._real_branch that changes state. In that case the underlying
2031
branch changes, so we need to invalidate this RemoteBranch's cache of
2032
it. However, there's no need to invalidate the _real_branch's cache
2033
too, in fact doing so might harm performance.
2035
super(RemoteBranch, self)._clear_cached_state()
2038
def control_files(self):
2039
# Defer actually creating RemoteBranchLockableFiles until its needed,
2040
# because it triggers an _ensure_real that we otherwise might not need.
2041
if self._control_files is None:
2042
self._control_files = RemoteBranchLockableFiles(
2043
self.bzrdir, self._client)
2044
return self._control_files
2046
def _get_checkout_format(self):
2048
return self._real_branch._get_checkout_format()
2050
def get_physical_lock_status(self):
2051
"""See Branch.get_physical_lock_status()."""
2052
# should be an API call to the server, as branches must be lockable.
2054
return self._real_branch.get_physical_lock_status()
2056
def get_stacked_on_url(self):
2057
"""Get the URL this branch is stacked against.
2059
:raises NotStacked: If the branch is not stacked.
2060
:raises UnstackableBranchFormat: If the branch does not support
2062
:raises UnstackableRepositoryFormat: If the repository does not support
2066
# there may not be a repository yet, so we can't use
2067
# self._translate_error, so we can't use self._call either.
2068
response = self._client.call('Branch.get_stacked_on_url',
2069
self._remote_path())
2070
except errors.ErrorFromSmartServer, err:
2071
# there may not be a repository yet, so we can't call through
2072
# its _translate_error
2073
_translate_error(err, branch=self)
2074
except errors.UnknownSmartMethod, err:
2076
return self._real_branch.get_stacked_on_url()
2077
if response[0] != 'ok':
2078
raise errors.UnexpectedSmartServerResponse(response)
2081
def _vfs_get_tags_bytes(self):
2083
return self._real_branch._get_tags_bytes()
2085
def _get_tags_bytes(self):
2086
medium = self._client._medium
2087
if medium._is_remote_before((1, 13)):
2088
return self._vfs_get_tags_bytes()
2090
response = self._call('Branch.get_tags_bytes', self._remote_path())
2091
except errors.UnknownSmartMethod:
2092
medium._remember_remote_is_before((1, 13))
2093
return self._vfs_get_tags_bytes()
2096
def lock_read(self):
2097
self.repository.lock_read()
2098
if not self._lock_mode:
2099
self._lock_mode = 'r'
2100
self._lock_count = 1
2101
if self._real_branch is not None:
2102
self._real_branch.lock_read()
2104
self._lock_count += 1
2106
def _remote_lock_write(self, token):
2108
branch_token = repo_token = ''
2110
branch_token = token
2111
repo_token = self.repository.lock_write()
2112
self.repository.unlock()
2113
err_context = {'token': token}
2114
response = self._call(
2115
'Branch.lock_write', self._remote_path(), branch_token,
2116
repo_token or '', **err_context)
2117
if response[0] != 'ok':
2118
raise errors.UnexpectedSmartServerResponse(response)
2119
ok, branch_token, repo_token = response
2120
return branch_token, repo_token
2122
def lock_write(self, token=None):
2123
if not self._lock_mode:
2124
# Lock the branch and repo in one remote call.
2125
remote_tokens = self._remote_lock_write(token)
2126
self._lock_token, self._repo_lock_token = remote_tokens
2127
if not self._lock_token:
2128
raise SmartProtocolError('Remote server did not return a token!')
2129
# Tell the self.repository object that it is locked.
2130
self.repository.lock_write(
2131
self._repo_lock_token, _skip_rpc=True)
2133
if self._real_branch is not None:
2134
self._real_branch.lock_write(token=self._lock_token)
2135
if token is not None:
2136
self._leave_lock = True
2138
self._leave_lock = False
2139
self._lock_mode = 'w'
2140
self._lock_count = 1
2141
elif self._lock_mode == 'r':
2142
raise errors.ReadOnlyTransaction
2144
if token is not None:
2145
# A token was given to lock_write, and we're relocking, so
2146
# check that the given token actually matches the one we
2148
if token != self._lock_token:
2149
raise errors.TokenMismatch(token, self._lock_token)
2150
self._lock_count += 1
2151
# Re-lock the repository too.
2152
self.repository.lock_write(self._repo_lock_token)
2153
return self._lock_token or None
2155
def _set_tags_bytes(self, bytes):
2157
return self._real_branch._set_tags_bytes(bytes)
2159
def _unlock(self, branch_token, repo_token):
2160
err_context = {'token': str((branch_token, repo_token))}
2161
response = self._call(
2162
'Branch.unlock', self._remote_path(), branch_token,
2163
repo_token or '', **err_context)
2164
if response == ('ok',):
2166
raise errors.UnexpectedSmartServerResponse(response)
2170
self._lock_count -= 1
2171
if not self._lock_count:
2172
self._clear_cached_state()
2173
mode = self._lock_mode
2174
self._lock_mode = None
2175
if self._real_branch is not None:
2176
if (not self._leave_lock and mode == 'w' and
2177
self._repo_lock_token):
2178
# If this RemoteBranch will remove the physical lock
2179
# for the repository, make sure the _real_branch
2180
# doesn't do it first. (Because the _real_branch's
2181
# repository is set to be the RemoteRepository.)
2182
self._real_branch.repository.leave_lock_in_place()
2183
self._real_branch.unlock()
2185
# Only write-locked branched need to make a remote method
2186
# call to perform the unlock.
2188
if not self._lock_token:
2189
raise AssertionError('Locked, but no token!')
2190
branch_token = self._lock_token
2191
repo_token = self._repo_lock_token
2192
self._lock_token = None
2193
self._repo_lock_token = None
2194
if not self._leave_lock:
2195
self._unlock(branch_token, repo_token)
2197
self.repository.unlock()
2199
def break_lock(self):
2201
return self._real_branch.break_lock()
2203
def leave_lock_in_place(self):
2204
if not self._lock_token:
2205
raise NotImplementedError(self.leave_lock_in_place)
2206
self._leave_lock = True
2208
def dont_leave_lock_in_place(self):
2209
if not self._lock_token:
2210
raise NotImplementedError(self.dont_leave_lock_in_place)
2211
self._leave_lock = False
2213
def _last_revision_info(self):
2214
response = self._call('Branch.last_revision_info', self._remote_path())
2215
if response[0] != 'ok':
2216
raise SmartProtocolError('unexpected response code %s' % (response,))
2217
revno = int(response[1])
2218
last_revision = response[2]
2219
return (revno, last_revision)
2221
def _gen_revision_history(self):
2222
"""See Branch._gen_revision_history()."""
2223
response_tuple, response_handler = self._call_expecting_body(
2224
'Branch.revision_history', self._remote_path())
2225
if response_tuple[0] != 'ok':
2226
raise errors.UnexpectedSmartServerResponse(response_tuple)
2227
result = response_handler.read_body_bytes().split('\x00')
2232
def _remote_path(self):
2233
return self.bzrdir._path_for_remote_call(self._client)
2235
def _set_last_revision_descendant(self, revision_id, other_branch,
2236
allow_diverged=False, allow_overwrite_descendant=False):
2237
# This performs additional work to meet the hook contract; while its
2238
# undesirable, we have to synthesise the revno to call the hook, and
2239
# not calling the hook is worse as it means changes can't be prevented.
2240
# Having calculated this though, we can't just call into
2241
# set_last_revision_info as a simple call, because there is a set_rh
2242
# hook that some folk may still be using.
2243
old_revno, old_revid = self.last_revision_info()
2244
history = self._lefthand_history(revision_id)
2245
self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2246
err_context = {'other_branch': other_branch}
2247
response = self._call('Branch.set_last_revision_ex',
2248
self._remote_path(), self._lock_token, self._repo_lock_token,
2249
revision_id, int(allow_diverged), int(allow_overwrite_descendant),
2251
self._clear_cached_state()
2252
if len(response) != 3 and response[0] != 'ok':
2253
raise errors.UnexpectedSmartServerResponse(response)
2254
new_revno, new_revision_id = response[1:]
2255
self._last_revision_info_cache = new_revno, new_revision_id
2256
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2257
if self._real_branch is not None:
2258
cache = new_revno, new_revision_id
2259
self._real_branch._last_revision_info_cache = cache
2261
def _set_last_revision(self, revision_id):
2262
old_revno, old_revid = self.last_revision_info()
2263
# This performs additional work to meet the hook contract; while its
2264
# undesirable, we have to synthesise the revno to call the hook, and
2265
# not calling the hook is worse as it means changes can't be prevented.
2266
# Having calculated this though, we can't just call into
2267
# set_last_revision_info as a simple call, because there is a set_rh
2268
# hook that some folk may still be using.
2269
history = self._lefthand_history(revision_id)
2270
self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2271
self._clear_cached_state()
2272
response = self._call('Branch.set_last_revision',
2273
self._remote_path(), self._lock_token, self._repo_lock_token,
2275
if response != ('ok',):
2276
raise errors.UnexpectedSmartServerResponse(response)
2277
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2280
def set_revision_history(self, rev_history):
2281
# Send just the tip revision of the history; the server will generate
2282
# the full history from that. If the revision doesn't exist in this
2283
# branch, NoSuchRevision will be raised.
2284
if rev_history == []:
2287
rev_id = rev_history[-1]
2288
self._set_last_revision(rev_id)
2289
for hook in branch.Branch.hooks['set_rh']:
2290
hook(self, rev_history)
2291
self._cache_revision_history(rev_history)
2293
def _get_parent_location(self):
2294
medium = self._client._medium
2295
if medium._is_remote_before((1, 13)):
2296
return self._vfs_get_parent_location()
2298
response = self._call('Branch.get_parent', self._remote_path())
2299
except errors.UnknownSmartMethod:
2300
medium._remember_remote_is_before((1, 13))
2301
return self._vfs_get_parent_location()
2302
if len(response) != 1:
2303
raise errors.UnexpectedSmartServerResponse(response)
2304
parent_location = response[0]
2305
if parent_location == '':
2307
return parent_location
2309
def _vfs_get_parent_location(self):
2311
return self._real_branch._get_parent_location()
2313
def _set_parent_location(self, url):
2314
medium = self._client._medium
2315
if medium._is_remote_before((1, 15)):
2316
return self._vfs_set_parent_location(url)
2318
call_url = url or ''
2319
if type(call_url) is not str:
2320
raise AssertionError('url must be a str or None (%s)' % url)
2321
response = self._call('Branch.set_parent_location',
2322
self._remote_path(), self._lock_token, self._repo_lock_token,
2324
except errors.UnknownSmartMethod:
2325
medium._remember_remote_is_before((1, 15))
2326
return self._vfs_set_parent_location(url)
2328
raise errors.UnexpectedSmartServerResponse(response)
2330
def _vfs_set_parent_location(self, url):
2332
return self._real_branch._set_parent_location(url)
2335
def pull(self, source, overwrite=False, stop_revision=None,
2337
self._clear_cached_state_of_remote_branch_only()
2339
return self._real_branch.pull(
2340
source, overwrite=overwrite, stop_revision=stop_revision,
2341
_override_hook_target=self, **kwargs)
2344
def push(self, target, overwrite=False, stop_revision=None):
2346
return self._real_branch.push(
2347
target, overwrite=overwrite, stop_revision=stop_revision,
2348
_override_hook_source_branch=self)
2350
def is_locked(self):
2351
return self._lock_count >= 1
2354
def revision_id_to_revno(self, revision_id):
2356
return self._real_branch.revision_id_to_revno(revision_id)
2359
def set_last_revision_info(self, revno, revision_id):
2360
# XXX: These should be returned by the set_last_revision_info verb
2361
old_revno, old_revid = self.last_revision_info()
2362
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2363
revision_id = ensure_null(revision_id)
2365
response = self._call('Branch.set_last_revision_info',
2366
self._remote_path(), self._lock_token, self._repo_lock_token,
2367
str(revno), revision_id)
2368
except errors.UnknownSmartMethod:
2370
self._clear_cached_state_of_remote_branch_only()
2371
self._real_branch.set_last_revision_info(revno, revision_id)
2372
self._last_revision_info_cache = revno, revision_id
2374
if response == ('ok',):
2375
self._clear_cached_state()
2376
self._last_revision_info_cache = revno, revision_id
2377
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2378
# Update the _real_branch's cache too.
2379
if self._real_branch is not None:
2380
cache = self._last_revision_info_cache
2381
self._real_branch._last_revision_info_cache = cache
2383
raise errors.UnexpectedSmartServerResponse(response)
2386
def generate_revision_history(self, revision_id, last_rev=None,
2388
medium = self._client._medium
2389
if not medium._is_remote_before((1, 6)):
2390
# Use a smart method for 1.6 and above servers
2392
self._set_last_revision_descendant(revision_id, other_branch,
2393
allow_diverged=True, allow_overwrite_descendant=True)
2395
except errors.UnknownSmartMethod:
2396
medium._remember_remote_is_before((1, 6))
2397
self._clear_cached_state_of_remote_branch_only()
2398
self.set_revision_history(self._lefthand_history(revision_id,
2399
last_rev=last_rev,other_branch=other_branch))
2401
def set_push_location(self, location):
2403
return self._real_branch.set_push_location(location)
2406
class RemoteConfig(object):
2407
"""A Config that reads and writes from smart verbs.
2409
It is a low-level object that considers config data to be name/value pairs
2410
that may be associated with a section. Assigning meaning to the these
2411
values is done at higher levels like bzrlib.config.TreeConfig.
2414
def get_option(self, name, section=None, default=None):
2415
"""Return the value associated with a named option.
2417
:param name: The name of the value
2418
:param section: The section the option is in (if any)
2419
:param default: The value to return if the value is not set
2420
:return: The value or default value
2423
configobj = self._get_configobj()
2425
section_obj = configobj
2428
section_obj = configobj[section]
2431
return section_obj.get(name, default)
2432
except errors.UnknownSmartMethod:
2433
return self._vfs_get_option(name, section, default)
2435
def _response_to_configobj(self, response):
2436
if len(response[0]) and response[0][0] != 'ok':
2437
raise errors.UnexpectedSmartServerResponse(response)
2438
lines = response[1].read_body_bytes().splitlines()
2439
return config.ConfigObj(lines, encoding='utf-8')
2442
class RemoteBranchConfig(RemoteConfig):
2443
"""A RemoteConfig for Branches."""
2445
def __init__(self, branch):
2446
self._branch = branch
2448
def _get_configobj(self):
2449
path = self._branch._remote_path()
2450
response = self._branch._client.call_expecting_body(
2451
'Branch.get_config_file', path)
2452
return self._response_to_configobj(response)
2454
def set_option(self, value, name, section=None):
2455
"""Set the value associated with a named option.
2457
:param value: The value to set
2458
:param name: The name of the value to set
2459
:param section: The section the option is in (if any)
2461
medium = self._branch._client._medium
2462
if medium._is_remote_before((1, 14)):
2463
return self._vfs_set_option(value, name, section)
2465
path = self._branch._remote_path()
2466
response = self._branch._client.call('Branch.set_config_option',
2467
path, self._branch._lock_token, self._branch._repo_lock_token,
2468
value.encode('utf8'), name, section or '')
2469
except errors.UnknownSmartMethod:
2470
medium._remember_remote_is_before((1, 14))
2471
return self._vfs_set_option(value, name, section)
2473
raise errors.UnexpectedSmartServerResponse(response)
2475
def _real_object(self):
2476
self._branch._ensure_real()
2477
return self._branch._real_branch
2479
def _vfs_set_option(self, value, name, section=None):
2480
return self._real_object()._get_config().set_option(
2481
value, name, section)
2484
class RemoteBzrDirConfig(RemoteConfig):
2485
"""A RemoteConfig for BzrDirs."""
2487
def __init__(self, bzrdir):
2488
self._bzrdir = bzrdir
2490
def _get_configobj(self):
2491
medium = self._bzrdir._client._medium
2492
verb = 'BzrDir.get_config_file'
2493
if medium._is_remote_before((1, 15)):
2494
raise errors.UnknownSmartMethod(verb)
2495
path = self._bzrdir._path_for_remote_call(self._bzrdir._client)
2496
response = self._bzrdir._call_expecting_body(
2498
return self._response_to_configobj(response)
2500
def _vfs_get_option(self, name, section, default):
2501
return self._real_object()._get_config().get_option(
2502
name, section, default)
2504
def set_option(self, value, name, section=None):
2505
"""Set the value associated with a named option.
2507
:param value: The value to set
2508
:param name: The name of the value to set
2509
:param section: The section the option is in (if any)
2511
return self._real_object()._get_config().set_option(
2512
value, name, section)
2514
def _real_object(self):
2515
self._bzrdir._ensure_real()
2516
return self._bzrdir._real_bzrdir
2520
def _extract_tar(tar, to_dir):
2521
"""Extract all the contents of a tarfile object.
2523
A replacement for extractall, which is not present in python2.4
2526
tar.extract(tarinfo, to_dir)
2529
def _translate_error(err, **context):
2530
"""Translate an ErrorFromSmartServer into a more useful error.
2532
Possible context keys:
2540
If the error from the server doesn't match a known pattern, then
2541
UnknownErrorFromSmartServer is raised.
2545
return context[name]
2546
except KeyError, key_err:
2547
mutter('Missing key %r in context %r', key_err.args[0], context)
2550
"""Get the path from the context if present, otherwise use first error
2554
return context['path']
2555
except KeyError, key_err:
2557
return err.error_args[0]
2558
except IndexError, idx_err:
2560
'Missing key %r in context %r', key_err.args[0], context)
2563
if err.error_verb == 'NoSuchRevision':
2564
raise NoSuchRevision(find('branch'), err.error_args[0])
2565
elif err.error_verb == 'nosuchrevision':
2566
raise NoSuchRevision(find('repository'), err.error_args[0])
2567
elif err.error_tuple == ('nobranch',):
2568
raise errors.NotBranchError(path=find('bzrdir').root_transport.base)
2569
elif err.error_verb == 'norepository':
2570
raise errors.NoRepositoryPresent(find('bzrdir'))
2571
elif err.error_verb == 'LockContention':
2572
raise errors.LockContention('(remote lock)')
2573
elif err.error_verb == 'UnlockableTransport':
2574
raise errors.UnlockableTransport(find('bzrdir').root_transport)
2575
elif err.error_verb == 'LockFailed':
2576
raise errors.LockFailed(err.error_args[0], err.error_args[1])
2577
elif err.error_verb == 'TokenMismatch':
2578
raise errors.TokenMismatch(find('token'), '(remote token)')
2579
elif err.error_verb == 'Diverged':
2580
raise errors.DivergedBranches(find('branch'), find('other_branch'))
2581
elif err.error_verb == 'TipChangeRejected':
2582
raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
2583
elif err.error_verb == 'UnstackableBranchFormat':
2584
raise errors.UnstackableBranchFormat(*err.error_args)
2585
elif err.error_verb == 'UnstackableRepositoryFormat':
2586
raise errors.UnstackableRepositoryFormat(*err.error_args)
2587
elif err.error_verb == 'NotStacked':
2588
raise errors.NotStacked(branch=find('branch'))
2589
elif err.error_verb == 'PermissionDenied':
2591
if len(err.error_args) >= 2:
2592
extra = err.error_args[1]
2595
raise errors.PermissionDenied(path, extra=extra)
2596
elif err.error_verb == 'ReadError':
2598
raise errors.ReadError(path)
2599
elif err.error_verb == 'NoSuchFile':
2601
raise errors.NoSuchFile(path)
2602
elif err.error_verb == 'FileExists':
2603
raise errors.FileExists(err.error_args[0])
2604
elif err.error_verb == 'DirectoryNotEmpty':
2605
raise errors.DirectoryNotEmpty(err.error_args[0])
2606
elif err.error_verb == 'ShortReadvError':
2607
args = err.error_args
2608
raise errors.ShortReadvError(
2609
args[0], int(args[1]), int(args[2]), int(args[3]))
2610
elif err.error_verb in ('UnicodeEncodeError', 'UnicodeDecodeError'):
2611
encoding = str(err.error_args[0]) # encoding must always be a string
2612
val = err.error_args[1]
2613
start = int(err.error_args[2])
2614
end = int(err.error_args[3])
2615
reason = str(err.error_args[4]) # reason must always be a string
2616
if val.startswith('u:'):
2617
val = val[2:].decode('utf-8')
2618
elif val.startswith('s:'):
2619
val = val[2:].decode('base64')
2620
if err.error_verb == 'UnicodeDecodeError':
2621
raise UnicodeDecodeError(encoding, val, start, end, reason)
2622
elif err.error_verb == 'UnicodeEncodeError':
2623
raise UnicodeEncodeError(encoding, val, start, end, reason)
2624
elif err.error_verb == 'ReadOnlyError':
2625
raise errors.TransportNotPossible('readonly transport')
2626
raise errors.UnknownErrorFromSmartServer(err)
added
removed
bzrlib/remote.py
