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.
36
from bzrlib.branch import BranchReferenceFormat
37
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
38
from bzrlib.decorators import needs_read_lock, needs_write_lock
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.trace import mutter, note, warning
47
from bzrlib.util import bencode
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_expecting_body(self, method, args, body_bytes,
68
return self._client.call_with_body_bytes_expecting_body(
69
method, args, body_bytes)
70
except errors.ErrorFromSmartServer, err:
71
self._translate_error(err, **err_context)
74
def response_tuple_to_repo_format(response):
75
"""Convert a response tuple describing a repository format to a format."""
76
format = RemoteRepositoryFormat()
77
format._rich_root_data = (response[0] == 'yes')
78
format._supports_tree_reference = (response[1] == 'yes')
79
format._supports_external_lookups = (response[2] == 'yes')
80
format._network_name = response[3]
84
# Note: RemoteBzrDirFormat is in bzrdir.py
86
class RemoteBzrDir(BzrDir, _RpcHelper):
87
"""Control directory on a remote server, accessed via bzr:// or similar."""
89
def __init__(self, transport, format, _client=None):
90
"""Construct a RemoteBzrDir.
92
:param _client: Private parameter for testing. Disables probing and the
95
BzrDir.__init__(self, transport, format)
96
# this object holds a delegated bzrdir that uses file-level operations
97
# to talk to the other side
98
self._real_bzrdir = None
99
# 1-shot cache for the call pattern 'create_branch; open_branch' - see
100
# create_branch for details.
101
self._next_open_branch_result = None
104
medium = transport.get_smart_medium()
105
self._client = client._SmartClient(medium)
107
self._client = _client
110
path = self._path_for_remote_call(self._client)
111
response = self._call('BzrDir.open', path)
112
if response not in [('yes',), ('no',)]:
113
raise errors.UnexpectedSmartServerResponse(response)
114
if response == ('no',):
115
raise errors.NotBranchError(path=transport.base)
117
def _ensure_real(self):
118
"""Ensure that there is a _real_bzrdir set.
120
Used before calls to self._real_bzrdir.
122
if not self._real_bzrdir:
123
self._real_bzrdir = BzrDir.open_from_transport(
124
self.root_transport, _server_formats=False)
125
self._format._network_name = \
126
self._real_bzrdir._format.network_name()
128
def _translate_error(self, err, **context):
129
_translate_error(err, bzrdir=self, **context)
131
def break_lock(self):
132
# Prevent aliasing problems in the next_open_branch_result cache.
133
# See create_branch for rationale.
134
self._next_open_branch_result = None
135
return BzrDir.break_lock(self)
137
def _vfs_cloning_metadir(self, require_stacking=False):
139
return self._real_bzrdir.cloning_metadir(
140
require_stacking=require_stacking)
142
def cloning_metadir(self, require_stacking=False):
143
medium = self._client._medium
144
if medium._is_remote_before((1, 13)):
145
return self._vfs_cloning_metadir(require_stacking=require_stacking)
146
verb = 'BzrDir.cloning_metadir'
151
path = self._path_for_remote_call(self._client)
153
response = self._call(verb, path, stacking)
154
except errors.UnknownSmartMethod:
155
medium._remember_remote_is_before((1, 13))
156
return self._vfs_cloning_metadir(require_stacking=require_stacking)
157
except errors.UnknownErrorFromSmartServer, err:
158
if err.error_tuple != ('BranchReference',):
160
# We need to resolve the branch reference to determine the
161
# cloning_metadir. This causes unnecessary RPCs to open the
162
# referenced branch (and bzrdir, etc) but only when the caller
163
# didn't already resolve the branch reference.
164
referenced_branch = self.open_branch()
165
return referenced_branch.bzrdir.cloning_metadir()
166
if len(response) != 3:
167
raise errors.UnexpectedSmartServerResponse(response)
168
control_name, repo_name, branch_info = response
169
if len(branch_info) != 2:
170
raise errors.UnexpectedSmartServerResponse(response)
171
branch_ref, branch_name = branch_info
172
format = bzrdir.network_format_registry.get(control_name)
174
format.repository_format = repository.network_format_registry.get(
176
if branch_ref == 'ref':
177
# XXX: we need possible_transports here to avoid reopening the
178
# connection to the referenced location
179
ref_bzrdir = BzrDir.open(branch_name)
180
branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
181
format.set_branch_format(branch_format)
182
elif branch_ref == 'branch':
184
format.set_branch_format(
185
branch.network_format_registry.get(branch_name))
187
raise errors.UnexpectedSmartServerResponse(response)
190
def create_repository(self, shared=False):
191
# as per meta1 formats - just delegate to the format object which may
193
result = self._format.repository_format.initialize(self, shared)
194
if not isinstance(result, RemoteRepository):
195
return self.open_repository()
199
def destroy_repository(self):
200
"""See BzrDir.destroy_repository"""
202
self._real_bzrdir.destroy_repository()
204
def create_branch(self):
205
# as per meta1 formats - just delegate to the format object which may
207
real_branch = self._format.get_branch_format().initialize(self)
208
if not isinstance(real_branch, RemoteBranch):
209
result = RemoteBranch(self, self.find_repository(), real_branch)
212
# BzrDir.clone_on_transport() uses the result of create_branch but does
213
# not return it to its callers; we save approximately 8% of our round
214
# trips by handing the branch we created back to the first caller to
215
# open_branch rather than probing anew. Long term we need a API in
216
# bzrdir that doesn't discard result objects (like result_branch).
218
self._next_open_branch_result = result
221
def destroy_branch(self):
222
"""See BzrDir.destroy_branch"""
224
self._real_bzrdir.destroy_branch()
225
self._next_open_branch_result = None
227
def create_workingtree(self, revision_id=None, from_branch=None):
228
raise errors.NotLocalUrl(self.transport.base)
230
def find_branch_format(self):
231
"""Find the branch 'format' for this bzrdir.
233
This might be a synthetic object for e.g. RemoteBranch and SVN.
235
b = self.open_branch()
238
def get_branch_reference(self):
239
"""See BzrDir.get_branch_reference()."""
240
response = self._get_branch_reference()
241
if response[0] == 'ref':
246
def _get_branch_reference(self):
247
path = self._path_for_remote_call(self._client)
248
medium = self._client._medium
249
if not medium._is_remote_before((1, 13)):
251
response = self._call('BzrDir.open_branchV2', path)
252
if response[0] not in ('ref', 'branch'):
253
raise errors.UnexpectedSmartServerResponse(response)
255
except errors.UnknownSmartMethod:
256
medium._remember_remote_is_before((1, 13))
257
response = self._call('BzrDir.open_branch', path)
258
if response[0] != 'ok':
259
raise errors.UnexpectedSmartServerResponse(response)
260
if response[1] != '':
261
return ('ref', response[1])
263
return ('branch', '')
265
def _get_tree_branch(self):
266
"""See BzrDir._get_tree_branch()."""
267
return None, self.open_branch()
269
def open_branch(self, _unsupported=False, ignore_fallbacks=False):
271
raise NotImplementedError('unsupported flag support not implemented yet.')
272
if self._next_open_branch_result is not None:
273
# See create_branch for details.
274
result = self._next_open_branch_result
275
self._next_open_branch_result = None
277
response = self._get_branch_reference()
278
if response[0] == 'ref':
279
# a branch reference, use the existing BranchReference logic.
280
format = BranchReferenceFormat()
281
return format.open(self, _found=True, location=response[1],
282
ignore_fallbacks=ignore_fallbacks)
283
branch_format_name = response[1]
284
if not branch_format_name:
285
branch_format_name = None
286
format = RemoteBranchFormat(network_name=branch_format_name)
287
return RemoteBranch(self, self.find_repository(), format=format,
288
setup_stacking=not ignore_fallbacks)
290
def _open_repo_v1(self, path):
291
verb = 'BzrDir.find_repository'
292
response = self._call(verb, path)
293
if response[0] != 'ok':
294
raise errors.UnexpectedSmartServerResponse(response)
295
# servers that only support the v1 method don't support external
298
repo = self._real_bzrdir.open_repository()
299
response = response + ('no', repo._format.network_name())
300
return response, repo
302
def _open_repo_v2(self, path):
303
verb = 'BzrDir.find_repositoryV2'
304
response = self._call(verb, path)
305
if response[0] != 'ok':
306
raise errors.UnexpectedSmartServerResponse(response)
308
repo = self._real_bzrdir.open_repository()
309
response = response + (repo._format.network_name(),)
310
return response, repo
312
def _open_repo_v3(self, path):
313
verb = 'BzrDir.find_repositoryV3'
314
medium = self._client._medium
315
if medium._is_remote_before((1, 13)):
316
raise errors.UnknownSmartMethod(verb)
318
response = self._call(verb, path)
319
except errors.UnknownSmartMethod:
320
medium._remember_remote_is_before((1, 13))
322
if response[0] != 'ok':
323
raise errors.UnexpectedSmartServerResponse(response)
324
return response, None
326
def open_repository(self):
327
path = self._path_for_remote_call(self._client)
329
for probe in [self._open_repo_v3, self._open_repo_v2,
332
response, real_repo = probe(path)
334
except errors.UnknownSmartMethod:
337
raise errors.UnknownSmartMethod('BzrDir.find_repository{3,2,}')
338
if response[0] != 'ok':
339
raise errors.UnexpectedSmartServerResponse(response)
340
if len(response) != 6:
341
raise SmartProtocolError('incorrect response length %s' % (response,))
342
if response[1] == '':
343
# repo is at this dir.
344
format = response_tuple_to_repo_format(response[2:])
345
# Used to support creating a real format instance when needed.
346
format._creating_bzrdir = self
347
remote_repo = RemoteRepository(self, format)
348
format._creating_repo = remote_repo
349
if real_repo is not None:
350
remote_repo._set_real_repository(real_repo)
353
raise errors.NoRepositoryPresent(self)
355
def open_workingtree(self, recommend_upgrade=True):
357
if self._real_bzrdir.has_workingtree():
358
raise errors.NotLocalUrl(self.root_transport)
360
raise errors.NoWorkingTree(self.root_transport.base)
362
def _path_for_remote_call(self, client):
363
"""Return the path to be used for this bzrdir in a remote call."""
364
return client.remote_path_from_transport(self.root_transport)
366
def get_branch_transport(self, branch_format):
368
return self._real_bzrdir.get_branch_transport(branch_format)
370
def get_repository_transport(self, repository_format):
372
return self._real_bzrdir.get_repository_transport(repository_format)
374
def get_workingtree_transport(self, workingtree_format):
376
return self._real_bzrdir.get_workingtree_transport(workingtree_format)
378
def can_convert_format(self):
379
"""Upgrading of remote bzrdirs is not supported yet."""
382
def needs_format_conversion(self, format=None):
383
"""Upgrading of remote bzrdirs is not supported yet."""
385
symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
386
% 'needs_format_conversion(format=None)')
389
def clone(self, url, revision_id=None, force_new_repo=False,
390
preserve_stacking=False):
392
return self._real_bzrdir.clone(url, revision_id=revision_id,
393
force_new_repo=force_new_repo, preserve_stacking=preserve_stacking)
395
def get_config(self):
397
return self._real_bzrdir.get_config()
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()
496
# Select the current bzrlib default and ask for that.
497
reference_bzrdir_format = bzrdir.format_registry.get('default')()
498
reference_format = reference_bzrdir_format.repository_format
499
network_name = reference_format.network_name()
500
# 2) try direct creation via RPC
501
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
502
verb = 'BzrDir.create_repository'
508
response = a_bzrdir._call(verb, path, network_name, shared_str)
509
except errors.UnknownSmartMethod:
510
# Fallback - use vfs methods
511
medium._remember_remote_is_before((1, 13))
512
return self._vfs_initialize(a_bzrdir, shared)
514
# Turn the response into a RemoteRepository object.
515
format = response_tuple_to_repo_format(response[1:])
516
# Used to support creating a real format instance when needed.
517
format._creating_bzrdir = a_bzrdir
518
remote_repo = RemoteRepository(a_bzrdir, format)
519
format._creating_repo = remote_repo
522
def open(self, a_bzrdir):
523
if not isinstance(a_bzrdir, RemoteBzrDir):
524
raise AssertionError('%r is not a RemoteBzrDir' % (a_bzrdir,))
525
return a_bzrdir.open_repository()
527
def _ensure_real(self):
528
if self._custom_format is None:
529
self._custom_format = repository.network_format_registry.get(
533
def _fetch_order(self):
535
return self._custom_format._fetch_order
538
def _fetch_uses_deltas(self):
540
return self._custom_format._fetch_uses_deltas
543
def _fetch_reconcile(self):
545
return self._custom_format._fetch_reconcile
547
def get_format_description(self):
548
return 'bzr remote repository'
550
def __eq__(self, other):
551
return self.__class__ is other.__class__
553
def check_conversion_target(self, target_format):
554
if self.rich_root_data and not target_format.rich_root_data:
555
raise errors.BadConversionTarget(
556
'Does not support rich root data.', target_format)
557
if (self.supports_tree_reference and
558
not getattr(target_format, 'supports_tree_reference', False)):
559
raise errors.BadConversionTarget(
560
'Does not support nested trees', target_format)
562
def network_name(self):
563
if self._network_name:
564
return self._network_name
565
self._creating_repo._ensure_real()
566
return self._creating_repo._real_repository._format.network_name()
569
def _serializer(self):
571
return self._custom_format._serializer
574
class RemoteRepository(_RpcHelper):
575
"""Repository accessed over rpc.
577
For the moment most operations are performed using local transport-backed
581
def __init__(self, remote_bzrdir, format, real_repository=None, _client=None):
582
"""Create a RemoteRepository instance.
584
:param remote_bzrdir: The bzrdir hosting this repository.
585
:param format: The RemoteFormat object to use.
586
:param real_repository: If not None, a local implementation of the
587
repository logic for the repository, usually accessing the data
589
:param _client: Private testing parameter - override the smart client
590
to be used by the repository.
593
self._real_repository = real_repository
595
self._real_repository = None
596
self.bzrdir = remote_bzrdir
598
self._client = remote_bzrdir._client
600
self._client = _client
601
self._format = format
602
self._lock_mode = None
603
self._lock_token = None
605
self._leave_lock = False
606
self._unstacked_provider = graph.CachingParentsProvider(
607
get_parent_map=self._get_parent_map_rpc)
608
self._unstacked_provider.disable_cache()
610
# These depend on the actual remote format, so force them off for
611
# maximum compatibility. XXX: In future these should depend on the
612
# remote repository instance, but this is irrelevant until we perform
613
# reconcile via an RPC call.
614
self._reconcile_does_inventory_gc = False
615
self._reconcile_fixes_text_parents = False
616
self._reconcile_backsup_inventory = False
617
self.base = self.bzrdir.transport.base
618
# Additional places to query for data.
619
self._fallback_repositories = []
622
return "%s(%s)" % (self.__class__.__name__, self.base)
626
def abort_write_group(self, suppress_errors=False):
627
"""Complete a write group on the decorated repository.
629
Smart methods peform operations in a single step so this api
630
is not really applicable except as a compatibility thunk
631
for older plugins that don't use e.g. the CommitBuilder
634
:param suppress_errors: see Repository.abort_write_group.
637
return self._real_repository.abort_write_group(
638
suppress_errors=suppress_errors)
640
def commit_write_group(self):
641
"""Complete a write group on the decorated repository.
643
Smart methods peform operations in a single step so this api
644
is not really applicable except as a compatibility thunk
645
for older plugins that don't use e.g. the CommitBuilder
649
return self._real_repository.commit_write_group()
651
def resume_write_group(self, tokens):
653
return self._real_repository.resume_write_group(tokens)
655
def suspend_write_group(self):
657
return self._real_repository.suspend_write_group()
659
def _ensure_real(self):
660
"""Ensure that there is a _real_repository set.
662
Used before calls to self._real_repository.
664
Note that _ensure_real causes many roundtrips to the server which are
665
not desirable, and prevents the use of smart one-roundtrip RPC's to
666
perform complex operations (such as accessing parent data, streaming
667
revisions etc). Adding calls to _ensure_real should only be done when
668
bringing up new functionality, adding fallbacks for smart methods that
669
require a fallback path, and never to replace an existing smart method
670
invocation. If in doubt chat to the bzr network team.
672
if self._real_repository is None:
673
self.bzrdir._ensure_real()
674
self._set_real_repository(
675
self.bzrdir._real_bzrdir.open_repository())
677
def _translate_error(self, err, **context):
678
self.bzrdir._translate_error(err, repository=self, **context)
680
def find_text_key_references(self):
681
"""Find the text key references within the repository.
683
:return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
684
revision_ids. Each altered file-ids has the exact revision_ids that
685
altered it listed explicitly.
686
:return: A dictionary mapping text keys ((fileid, revision_id) tuples)
687
to whether they were referred to by the inventory of the
688
revision_id that they contain. The inventory texts from all present
689
revision ids are assessed to generate this report.
692
return self._real_repository.find_text_key_references()
694
def _generate_text_key_index(self):
695
"""Generate a new text key index for the repository.
697
This is an expensive function that will take considerable time to run.
699
:return: A dict mapping (file_id, revision_id) tuples to a list of
700
parents, also (file_id, revision_id) tuples.
703
return self._real_repository._generate_text_key_index()
705
def _get_revision_graph(self, revision_id):
706
"""Private method for using with old (< 1.2) servers to fallback."""
707
if revision_id is None:
709
elif revision.is_null(revision_id):
712
path = self.bzrdir._path_for_remote_call(self._client)
713
response = self._call_expecting_body(
714
'Repository.get_revision_graph', path, revision_id)
715
response_tuple, response_handler = response
716
if response_tuple[0] != 'ok':
717
raise errors.UnexpectedSmartServerResponse(response_tuple)
718
coded = response_handler.read_body_bytes()
720
# no revisions in this repository!
722
lines = coded.split('\n')
725
d = tuple(line.split())
726
revision_graph[d[0]] = d[1:]
728
return revision_graph
731
"""See Repository._get_sink()."""
732
return RemoteStreamSink(self)
734
def _get_source(self, to_format):
735
"""Return a source for streaming from this repository."""
736
return RemoteStreamSource(self, to_format)
738
def has_revision(self, revision_id):
739
"""See Repository.has_revision()."""
740
if revision_id == NULL_REVISION:
741
# The null revision is always present.
743
path = self.bzrdir._path_for_remote_call(self._client)
744
response = self._call('Repository.has_revision', path, revision_id)
745
if response[0] not in ('yes', 'no'):
746
raise errors.UnexpectedSmartServerResponse(response)
747
if response[0] == 'yes':
749
for fallback_repo in self._fallback_repositories:
750
if fallback_repo.has_revision(revision_id):
754
def has_revisions(self, revision_ids):
755
"""See Repository.has_revisions()."""
756
# FIXME: This does many roundtrips, particularly when there are
757
# fallback repositories. -- mbp 20080905
759
for revision_id in revision_ids:
760
if self.has_revision(revision_id):
761
result.add(revision_id)
764
def has_same_location(self, other):
765
return (self.__class__ is other.__class__ and
766
self.bzrdir.transport.base == other.bzrdir.transport.base)
768
def get_graph(self, other_repository=None):
769
"""Return the graph for this repository format"""
770
parents_provider = self._make_parents_provider(other_repository)
771
return graph.Graph(parents_provider)
773
def gather_stats(self, revid=None, committers=None):
774
"""See Repository.gather_stats()."""
775
path = self.bzrdir._path_for_remote_call(self._client)
776
# revid can be None to indicate no revisions, not just NULL_REVISION
777
if revid is None or revision.is_null(revid):
781
if committers is None or not committers:
782
fmt_committers = 'no'
784
fmt_committers = 'yes'
785
response_tuple, response_handler = self._call_expecting_body(
786
'Repository.gather_stats', path, fmt_revid, fmt_committers)
787
if response_tuple[0] != 'ok':
788
raise errors.UnexpectedSmartServerResponse(response_tuple)
790
body = response_handler.read_body_bytes()
792
for line in body.split('\n'):
795
key, val_text = line.split(':')
796
if key in ('revisions', 'size', 'committers'):
797
result[key] = int(val_text)
798
elif key in ('firstrev', 'latestrev'):
799
values = val_text.split(' ')[1:]
800
result[key] = (float(values[0]), long(values[1]))
804
def find_branches(self, using=False):
805
"""See Repository.find_branches()."""
806
# should be an API call to the server.
808
return self._real_repository.find_branches(using=using)
810
def get_physical_lock_status(self):
811
"""See Repository.get_physical_lock_status()."""
812
# should be an API call to the server.
814
return self._real_repository.get_physical_lock_status()
816
def is_in_write_group(self):
817
"""Return True if there is an open write group.
819
write groups are only applicable locally for the smart server..
821
if self._real_repository:
822
return self._real_repository.is_in_write_group()
825
return self._lock_count >= 1
828
"""See Repository.is_shared()."""
829
path = self.bzrdir._path_for_remote_call(self._client)
830
response = self._call('Repository.is_shared', path)
831
if response[0] not in ('yes', 'no'):
832
raise SmartProtocolError('unexpected response code %s' % (response,))
833
return response[0] == 'yes'
835
def is_write_locked(self):
836
return self._lock_mode == 'w'
839
# wrong eventually - want a local lock cache context
840
if not self._lock_mode:
841
self._lock_mode = 'r'
843
self._unstacked_provider.enable_cache(cache_misses=True)
844
if self._real_repository is not None:
845
self._real_repository.lock_read()
847
self._lock_count += 1
848
for repo in self._fallback_repositories:
851
def _remote_lock_write(self, token):
852
path = self.bzrdir._path_for_remote_call(self._client)
855
err_context = {'token': token}
856
response = self._call('Repository.lock_write', path, token,
858
if response[0] == 'ok':
862
raise errors.UnexpectedSmartServerResponse(response)
864
def lock_write(self, token=None, _skip_rpc=False):
865
if not self._lock_mode:
867
if self._lock_token is not None:
868
if token != self._lock_token:
869
raise errors.TokenMismatch(token, self._lock_token)
870
self._lock_token = token
872
self._lock_token = self._remote_lock_write(token)
873
# if self._lock_token is None, then this is something like packs or
874
# svn where we don't get to lock the repo, or a weave style repository
875
# where we cannot lock it over the wire and attempts to do so will
877
if self._real_repository is not None:
878
self._real_repository.lock_write(token=self._lock_token)
879
if token is not None:
880
self._leave_lock = True
882
self._leave_lock = False
883
self._lock_mode = 'w'
885
self._unstacked_provider.enable_cache(cache_misses=False)
886
elif self._lock_mode == 'r':
887
raise errors.ReadOnlyError(self)
889
self._lock_count += 1
890
for repo in self._fallback_repositories:
891
# Writes don't affect fallback repos
893
return self._lock_token or None
895
def leave_lock_in_place(self):
896
if not self._lock_token:
897
raise NotImplementedError(self.leave_lock_in_place)
898
self._leave_lock = True
900
def dont_leave_lock_in_place(self):
901
if not self._lock_token:
902
raise NotImplementedError(self.dont_leave_lock_in_place)
903
self._leave_lock = False
905
def _set_real_repository(self, repository):
906
"""Set the _real_repository for this repository.
908
:param repository: The repository to fallback to for non-hpss
909
implemented operations.
911
if self._real_repository is not None:
912
# Replacing an already set real repository.
913
# We cannot do this [currently] if the repository is locked -
914
# synchronised state might be lost.
916
raise AssertionError('_real_repository is already set')
917
if isinstance(repository, RemoteRepository):
918
raise AssertionError()
919
self._real_repository = repository
920
if (len(self._real_repository._fallback_repositories) !=
921
len(self._fallback_repositories)):
922
if len(self._real_repository._fallback_repositories):
923
raise AssertionError(
924
"cannot cleanly remove existing _fallback_repositories")
925
for fb in self._fallback_repositories:
926
self._real_repository.add_fallback_repository(fb)
927
if self._lock_mode == 'w':
928
# if we are already locked, the real repository must be able to
929
# acquire the lock with our token.
930
self._real_repository.lock_write(self._lock_token)
931
elif self._lock_mode == 'r':
932
self._real_repository.lock_read()
934
def start_write_group(self):
935
"""Start a write group on the decorated repository.
937
Smart methods peform operations in a single step so this api
938
is not really applicable except as a compatibility thunk
939
for older plugins that don't use e.g. the CommitBuilder
943
return self._real_repository.start_write_group()
945
def _unlock(self, token):
946
path = self.bzrdir._path_for_remote_call(self._client)
948
# with no token the remote repository is not persistently locked.
950
err_context = {'token': token}
951
response = self._call('Repository.unlock', path, token,
953
if response == ('ok',):
956
raise errors.UnexpectedSmartServerResponse(response)
959
if not self._lock_count:
960
raise errors.LockNotHeld(self)
961
self._lock_count -= 1
962
if self._lock_count > 0:
964
self._unstacked_provider.disable_cache()
965
old_mode = self._lock_mode
966
self._lock_mode = None
968
# The real repository is responsible at present for raising an
969
# exception if it's in an unfinished write group. However, it
970
# normally will *not* actually remove the lock from disk - that's
971
# done by the server on receiving the Repository.unlock call.
972
# This is just to let the _real_repository stay up to date.
973
if self._real_repository is not None:
974
self._real_repository.unlock()
976
# The rpc-level lock should be released even if there was a
977
# problem releasing the vfs-based lock.
979
# Only write-locked repositories need to make a remote method
980
# call to perfom the unlock.
981
old_token = self._lock_token
982
self._lock_token = None
983
if not self._leave_lock:
984
self._unlock(old_token)
986
def break_lock(self):
987
# should hand off to the network
989
return self._real_repository.break_lock()
991
def _get_tarball(self, compression):
992
"""Return a TemporaryFile containing a repository tarball.
994
Returns None if the server does not support sending tarballs.
997
path = self.bzrdir._path_for_remote_call(self._client)
999
response, protocol = self._call_expecting_body(
1000
'Repository.tarball', path, compression)
1001
except errors.UnknownSmartMethod:
1002
protocol.cancel_read_body()
1004
if response[0] == 'ok':
1005
# Extract the tarball and return it
1006
t = tempfile.NamedTemporaryFile()
1007
# TODO: rpc layer should read directly into it...
1008
t.write(protocol.read_body_bytes())
1011
raise errors.UnexpectedSmartServerResponse(response)
1013
def sprout(self, to_bzrdir, revision_id=None):
1014
# TODO: Option to control what format is created?
1016
dest_repo = self._real_repository._format.initialize(to_bzrdir,
1018
dest_repo.fetch(self, revision_id=revision_id)
1021
### These methods are just thin shims to the VFS object for now.
1023
def revision_tree(self, revision_id):
1025
return self._real_repository.revision_tree(revision_id)
1027
def get_serializer_format(self):
1029
return self._real_repository.get_serializer_format()
1031
def get_commit_builder(self, branch, parents, config, timestamp=None,
1032
timezone=None, committer=None, revprops=None,
1034
# FIXME: It ought to be possible to call this without immediately
1035
# triggering _ensure_real. For now it's the easiest thing to do.
1037
real_repo = self._real_repository
1038
builder = real_repo.get_commit_builder(branch, parents,
1039
config, timestamp=timestamp, timezone=timezone,
1040
committer=committer, revprops=revprops, revision_id=revision_id)
1043
def add_fallback_repository(self, repository):
1044
"""Add a repository to use for looking up data not held locally.
1046
:param repository: A repository.
1048
if not self._format.supports_external_lookups:
1049
raise errors.UnstackableRepositoryFormat(
1050
self._format.network_name(), self.base)
1051
# We need to accumulate additional repositories here, to pass them in
1054
self._fallback_repositories.append(repository)
1055
# If self._real_repository was parameterised already (e.g. because a
1056
# _real_branch had its get_stacked_on_url method called), then the
1057
# repository to be added may already be in the _real_repositories list.
1058
if self._real_repository is not None:
1059
if repository not in self._real_repository._fallback_repositories:
1060
self._real_repository.add_fallback_repository(repository)
1062
def add_inventory(self, revid, inv, parents):
1064
return self._real_repository.add_inventory(revid, inv, parents)
1066
def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1069
return self._real_repository.add_inventory_by_delta(basis_revision_id,
1070
delta, new_revision_id, parents)
1072
def add_revision(self, rev_id, rev, inv=None, config=None):
1074
return self._real_repository.add_revision(
1075
rev_id, rev, inv=inv, config=config)
1078
def get_inventory(self, revision_id):
1080
return self._real_repository.get_inventory(revision_id)
1082
def iter_inventories(self, revision_ids):
1084
return self._real_repository.iter_inventories(revision_ids)
1087
def get_revision(self, revision_id):
1089
return self._real_repository.get_revision(revision_id)
1091
def get_transaction(self):
1093
return self._real_repository.get_transaction()
1096
def clone(self, a_bzrdir, revision_id=None):
1098
return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
1100
def make_working_trees(self):
1101
"""See Repository.make_working_trees"""
1103
return self._real_repository.make_working_trees()
1105
def refresh_data(self):
1106
"""Re-read any data needed to to synchronise with disk.
1108
This method is intended to be called after another repository instance
1109
(such as one used by a smart server) has inserted data into the
1110
repository. It may not be called during a write group, but may be
1111
called at any other time.
1113
if self.is_in_write_group():
1114
raise errors.InternalBzrError(
1115
"May not refresh_data while in a write group.")
1116
if self._real_repository is not None:
1117
self._real_repository.refresh_data()
1119
def revision_ids_to_search_result(self, result_set):
1120
"""Convert a set of revision ids to a graph SearchResult."""
1121
result_parents = set()
1122
for parents in self.get_graph().get_parent_map(
1123
result_set).itervalues():
1124
result_parents.update(parents)
1125
included_keys = result_set.intersection(result_parents)
1126
start_keys = result_set.difference(included_keys)
1127
exclude_keys = result_parents.difference(result_set)
1128
result = graph.SearchResult(start_keys, exclude_keys,
1129
len(result_set), result_set)
1133
def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1134
"""Return the revision ids that other has that this does not.
1136
These are returned in topological order.
1138
revision_id: only return revision ids included by revision_id.
1140
return repository.InterRepository.get(
1141
other, self).search_missing_revision_ids(revision_id, find_ghosts)
1143
def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
1145
# No base implementation to use as RemoteRepository is not a subclass
1146
# of Repository; so this is a copy of Repository.fetch().
1147
if fetch_spec is not None and revision_id is not None:
1148
raise AssertionError(
1149
"fetch_spec and revision_id are mutually exclusive.")
1150
if self.is_in_write_group():
1151
raise errors.InternalBzrError(
1152
"May not fetch while in a write group.")
1153
# fast path same-url fetch operations
1154
if self.has_same_location(source) and fetch_spec is None:
1155
# check that last_revision is in 'from' and then return a
1157
if (revision_id is not None and
1158
not revision.is_null(revision_id)):
1159
self.get_revision(revision_id)
1161
# if there is no specific appropriate InterRepository, this will get
1162
# the InterRepository base class, which raises an
1163
# IncompatibleRepositories when asked to fetch.
1164
inter = repository.InterRepository.get(source, self)
1165
return inter.fetch(revision_id=revision_id, pb=pb,
1166
find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1168
def create_bundle(self, target, base, fileobj, format=None):
1170
self._real_repository.create_bundle(target, base, fileobj, format)
1173
def get_ancestry(self, revision_id, topo_sorted=True):
1175
return self._real_repository.get_ancestry(revision_id, topo_sorted)
1177
def fileids_altered_by_revision_ids(self, revision_ids):
1179
return self._real_repository.fileids_altered_by_revision_ids(revision_ids)
1181
def _get_versioned_file_checker(self, revisions, revision_versions_cache):
1183
return self._real_repository._get_versioned_file_checker(
1184
revisions, revision_versions_cache)
1186
def iter_files_bytes(self, desired_files):
1187
"""See Repository.iter_file_bytes.
1190
return self._real_repository.iter_files_bytes(desired_files)
1192
def get_parent_map(self, revision_ids):
1193
"""See bzrlib.Graph.get_parent_map()."""
1194
return self._make_parents_provider().get_parent_map(revision_ids)
1196
def _get_parent_map_rpc(self, keys):
1197
"""Helper for get_parent_map that performs the RPC."""
1198
medium = self._client._medium
1199
if medium._is_remote_before((1, 2)):
1200
# We already found out that the server can't understand
1201
# Repository.get_parent_map requests, so just fetch the whole
1204
# Note that this reads the whole graph, when only some keys are
1205
# wanted. On this old server there's no way (?) to get them all
1206
# in one go, and the user probably will have seen a warning about
1207
# the server being old anyhow.
1208
rg = self._get_revision_graph(None)
1209
# There is an api discrepency between get_parent_map and
1210
# get_revision_graph. Specifically, a "key:()" pair in
1211
# get_revision_graph just means a node has no parents. For
1212
# "get_parent_map" it means the node is a ghost. So fix up the
1213
# graph to correct this.
1214
# https://bugs.launchpad.net/bzr/+bug/214894
1215
# There is one other "bug" which is that ghosts in
1216
# get_revision_graph() are not returned at all. But we won't worry
1217
# about that for now.
1218
for node_id, parent_ids in rg.iteritems():
1219
if parent_ids == ():
1220
rg[node_id] = (NULL_REVISION,)
1221
rg[NULL_REVISION] = ()
1226
raise ValueError('get_parent_map(None) is not valid')
1227
if NULL_REVISION in keys:
1228
keys.discard(NULL_REVISION)
1229
found_parents = {NULL_REVISION:()}
1231
return found_parents
1234
# TODO(Needs analysis): We could assume that the keys being requested
1235
# from get_parent_map are in a breadth first search, so typically they
1236
# will all be depth N from some common parent, and we don't have to
1237
# have the server iterate from the root parent, but rather from the
1238
# keys we're searching; and just tell the server the keyspace we
1239
# already have; but this may be more traffic again.
1241
# Transform self._parents_map into a search request recipe.
1242
# TODO: Manage this incrementally to avoid covering the same path
1243
# repeatedly. (The server will have to on each request, but the less
1244
# work done the better).
1246
# Negative caching notes:
1247
# new server sends missing when a request including the revid
1248
# 'include-missing:' is present in the request.
1249
# missing keys are serialised as missing:X, and we then call
1250
# provider.note_missing(X) for-all X
1251
parents_map = self._unstacked_provider.get_cached_map()
1252
if parents_map is None:
1253
# Repository is not locked, so there's no cache.
1255
# start_set is all the keys in the cache
1256
start_set = set(parents_map)
1257
# result set is all the references to keys in the cache
1258
result_parents = set()
1259
for parents in parents_map.itervalues():
1260
result_parents.update(parents)
1261
stop_keys = result_parents.difference(start_set)
1262
# We don't need to send ghosts back to the server as a position to
1264
stop_keys.difference_update(self._unstacked_provider.missing_keys)
1265
key_count = len(parents_map)
1266
if (NULL_REVISION in result_parents
1267
and NULL_REVISION in self._unstacked_provider.missing_keys):
1268
# If we pruned NULL_REVISION from the stop_keys because it's also
1269
# in our cache of "missing" keys we need to increment our key count
1270
# by 1, because the reconsitituted SearchResult on the server will
1271
# still consider NULL_REVISION to be an included key.
1273
included_keys = start_set.intersection(result_parents)
1274
start_set.difference_update(included_keys)
1275
recipe = ('manual', start_set, stop_keys, key_count)
1276
body = self._serialise_search_recipe(recipe)
1277
path = self.bzrdir._path_for_remote_call(self._client)
1279
if type(key) is not str:
1281
"key %r not a plain string" % (key,))
1282
verb = 'Repository.get_parent_map'
1283
args = (path, 'include-missing:') + tuple(keys)
1285
response = self._call_with_body_bytes_expecting_body(
1287
except errors.UnknownSmartMethod:
1288
# Server does not support this method, so get the whole graph.
1289
# Worse, we have to force a disconnection, because the server now
1290
# doesn't realise it has a body on the wire to consume, so the
1291
# only way to recover is to abandon the connection.
1293
'Server is too old for fast get_parent_map, reconnecting. '
1294
'(Upgrade the server to Bazaar 1.2 to avoid this)')
1296
# To avoid having to disconnect repeatedly, we keep track of the
1297
# fact the server doesn't understand remote methods added in 1.2.
1298
medium._remember_remote_is_before((1, 2))
1299
# Recurse just once and we should use the fallback code.
1300
return self._get_parent_map_rpc(keys)
1301
response_tuple, response_handler = response
1302
if response_tuple[0] not in ['ok']:
1303
response_handler.cancel_read_body()
1304
raise errors.UnexpectedSmartServerResponse(response_tuple)
1305
if response_tuple[0] == 'ok':
1306
coded = bz2.decompress(response_handler.read_body_bytes())
1308
# no revisions found
1310
lines = coded.split('\n')
1313
d = tuple(line.split())
1315
revision_graph[d[0]] = d[1:]
1318
if d[0].startswith('missing:'):
1320
self._unstacked_provider.note_missing_key(revid)
1322
# no parents - so give the Graph result
1324
revision_graph[d[0]] = (NULL_REVISION,)
1325
return revision_graph
1328
def get_signature_text(self, revision_id):
1330
return self._real_repository.get_signature_text(revision_id)
1333
def get_inventory_xml(self, revision_id):
1335
return self._real_repository.get_inventory_xml(revision_id)
1337
def deserialise_inventory(self, revision_id, xml):
1339
return self._real_repository.deserialise_inventory(revision_id, xml)
1341
def reconcile(self, other=None, thorough=False):
1343
return self._real_repository.reconcile(other=other, thorough=thorough)
1345
def all_revision_ids(self):
1347
return self._real_repository.all_revision_ids()
1350
def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1352
return self._real_repository.get_deltas_for_revisions(revisions,
1353
specific_fileids=specific_fileids)
1356
def get_revision_delta(self, revision_id, specific_fileids=None):
1358
return self._real_repository.get_revision_delta(revision_id,
1359
specific_fileids=specific_fileids)
1362
def revision_trees(self, revision_ids):
1364
return self._real_repository.revision_trees(revision_ids)
1367
def get_revision_reconcile(self, revision_id):
1369
return self._real_repository.get_revision_reconcile(revision_id)
1372
def check(self, revision_ids=None):
1374
return self._real_repository.check(revision_ids=revision_ids)
1376
def copy_content_into(self, destination, revision_id=None):
1378
return self._real_repository.copy_content_into(
1379
destination, revision_id=revision_id)
1381
def _copy_repository_tarball(self, to_bzrdir, revision_id=None):
1382
# get a tarball of the remote repository, and copy from that into the
1384
from bzrlib import osutils
1386
# TODO: Maybe a progress bar while streaming the tarball?
1387
note("Copying repository content as tarball...")
1388
tar_file = self._get_tarball('bz2')
1389
if tar_file is None:
1391
destination = to_bzrdir.create_repository()
1393
tar = tarfile.open('repository', fileobj=tar_file,
1395
tmpdir = osutils.mkdtemp()
1397
_extract_tar(tar, tmpdir)
1398
tmp_bzrdir = BzrDir.open(tmpdir)
1399
tmp_repo = tmp_bzrdir.open_repository()
1400
tmp_repo.copy_content_into(destination, revision_id)
1402
osutils.rmtree(tmpdir)
1406
# TODO: Suggestion from john: using external tar is much faster than
1407
# python's tarfile library, but it may not work on windows.
1410
def inventories(self):
1411
"""Decorate the real repository for now.
1413
In the long term a full blown network facility is needed to
1414
avoid creating a real repository object locally.
1417
return self._real_repository.inventories
1421
"""Compress the data within the repository.
1423
This is not currently implemented within the smart server.
1426
return self._real_repository.pack()
1429
def revisions(self):
1430
"""Decorate the real repository for now.
1432
In the short term this should become a real object to intercept graph
1435
In the long term a full blown network facility is needed.
1438
return self._real_repository.revisions
1440
def set_make_working_trees(self, new_value):
1442
new_value_str = "True"
1444
new_value_str = "False"
1445
path = self.bzrdir._path_for_remote_call(self._client)
1447
response = self._call(
1448
'Repository.set_make_working_trees', path, new_value_str)
1449
except errors.UnknownSmartMethod:
1451
self._real_repository.set_make_working_trees(new_value)
1453
if response[0] != 'ok':
1454
raise errors.UnexpectedSmartServerResponse(response)
1457
def signatures(self):
1458
"""Decorate the real repository for now.
1460
In the long term a full blown network facility is needed to avoid
1461
creating a real repository object locally.
1464
return self._real_repository.signatures
1467
def sign_revision(self, revision_id, gpg_strategy):
1469
return self._real_repository.sign_revision(revision_id, gpg_strategy)
1473
"""Decorate the real repository for now.
1475
In the long term a full blown network facility is needed to avoid
1476
creating a real repository object locally.
1479
return self._real_repository.texts
1482
def get_revisions(self, revision_ids):
1484
return self._real_repository.get_revisions(revision_ids)
1486
def supports_rich_root(self):
1487
return self._format.rich_root_data
1489
def iter_reverse_revision_history(self, revision_id):
1491
return self._real_repository.iter_reverse_revision_history(revision_id)
1494
def _serializer(self):
1495
return self._format._serializer
1497
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1499
return self._real_repository.store_revision_signature(
1500
gpg_strategy, plaintext, revision_id)
1502
def add_signature_text(self, revision_id, signature):
1504
return self._real_repository.add_signature_text(revision_id, signature)
1506
def has_signature_for_revision_id(self, revision_id):
1508
return self._real_repository.has_signature_for_revision_id(revision_id)
1510
def item_keys_introduced_by(self, revision_ids, _files_pb=None):
1512
return self._real_repository.item_keys_introduced_by(revision_ids,
1513
_files_pb=_files_pb)
1515
def revision_graph_can_have_wrong_parents(self):
1516
# The answer depends on the remote repo format.
1518
return self._real_repository.revision_graph_can_have_wrong_parents()
1520
def _find_inconsistent_revision_parents(self):
1522
return self._real_repository._find_inconsistent_revision_parents()
1524
def _check_for_inconsistent_revision_parents(self):
1526
return self._real_repository._check_for_inconsistent_revision_parents()
1528
def _make_parents_provider(self, other=None):
1529
providers = [self._unstacked_provider]
1530
if other is not None:
1531
providers.insert(0, other)
1532
providers.extend(r._make_parents_provider() for r in
1533
self._fallback_repositories)
1534
return graph._StackedParentsProvider(providers)
1536
def _serialise_search_recipe(self, recipe):
1537
"""Serialise a graph search recipe.
1539
:param recipe: A search recipe (start, stop, count).
1540
:return: Serialised bytes.
1542
start_keys = ' '.join(recipe[1])
1543
stop_keys = ' '.join(recipe[2])
1544
count = str(recipe[3])
1545
return '\n'.join((start_keys, stop_keys, count))
1547
def _serialise_search_result(self, search_result):
1548
if isinstance(search_result, graph.PendingAncestryResult):
1549
parts = ['ancestry-of']
1550
parts.extend(search_result.heads)
1552
recipe = search_result.get_recipe()
1553
parts = [recipe[0], self._serialise_search_recipe(recipe)]
1554
return '\n'.join(parts)
1557
path = self.bzrdir._path_for_remote_call(self._client)
1559
response = self._call('PackRepository.autopack', path)
1560
except errors.UnknownSmartMethod:
1562
self._real_repository._pack_collection.autopack()
1565
if response[0] != 'ok':
1566
raise errors.UnexpectedSmartServerResponse(response)
1569
class RemoteStreamSink(repository.StreamSink):
1571
def _insert_real(self, stream, src_format, resume_tokens):
1572
self.target_repo._ensure_real()
1573
sink = self.target_repo._real_repository._get_sink()
1574
result = sink.insert_stream(stream, src_format, resume_tokens)
1576
self.target_repo.autopack()
1579
def insert_stream(self, stream, src_format, resume_tokens):
1580
target = self.target_repo
1581
if target._lock_token:
1582
verb = 'Repository.insert_stream_locked'
1583
extra_args = (target._lock_token or '',)
1584
required_version = (1, 14)
1586
verb = 'Repository.insert_stream'
1588
required_version = (1, 13)
1589
client = target._client
1590
medium = client._medium
1591
if medium._is_remote_before(required_version):
1592
# No possible way this can work.
1593
return self._insert_real(stream, src_format, resume_tokens)
1594
path = target.bzrdir._path_for_remote_call(client)
1595
if not resume_tokens:
1596
# XXX: Ugly but important for correctness, *will* be fixed during
1597
# 1.13 cycle. Pushing a stream that is interrupted results in a
1598
# fallback to the _real_repositories sink *with a partial stream*.
1599
# Thats bad because we insert less data than bzr expected. To avoid
1600
# this we do a trial push to make sure the verb is accessible, and
1601
# do not fallback when actually pushing the stream. A cleanup patch
1602
# is going to look at rewinding/restarting the stream/partial
1604
byte_stream = smart_repo._stream_to_byte_stream([], src_format)
1606
response = client.call_with_body_stream(
1607
(verb, path, '') + extra_args, byte_stream)
1608
except errors.UnknownSmartMethod:
1609
medium._remember_remote_is_before(required_version)
1610
return self._insert_real(stream, src_format, resume_tokens)
1611
byte_stream = smart_repo._stream_to_byte_stream(
1613
resume_tokens = ' '.join(resume_tokens)
1614
response = client.call_with_body_stream(
1615
(verb, path, resume_tokens) + extra_args, byte_stream)
1616
if response[0][0] not in ('ok', 'missing-basis'):
1617
raise errors.UnexpectedSmartServerResponse(response)
1618
if response[0][0] == 'missing-basis':
1619
tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1620
resume_tokens = tokens
1621
return resume_tokens, missing_keys
1623
self.target_repo.refresh_data()
1627
class RemoteStreamSource(repository.StreamSource):
1628
"""Stream data from a remote server."""
1630
def get_stream(self, search):
1631
if (self.from_repository._fallback_repositories and
1632
self.to_format._fetch_order == 'topological'):
1633
return self._real_stream(self.from_repository, search)
1634
return self.missing_parents_chain(search, [self.from_repository] +
1635
self.from_repository._fallback_repositories)
1637
def _real_stream(self, repo, search):
1638
"""Get a stream for search from repo.
1640
This never called RemoteStreamSource.get_stream, and is a heler
1641
for RemoteStreamSource._get_stream to allow getting a stream
1642
reliably whether fallback back because of old servers or trying
1643
to stream from a non-RemoteRepository (which the stacked support
1646
source = repo._get_source(self.to_format)
1647
if isinstance(source, RemoteStreamSource):
1648
return repository.StreamSource.get_stream(source, search)
1649
return source.get_stream(search)
1651
def _get_stream(self, repo, search):
1652
"""Core worker to get a stream from repo for search.
1654
This is used by both get_stream and the stacking support logic. It
1655
deliberately gets a stream for repo which does not need to be
1656
self.from_repository. In the event that repo is not Remote, or
1657
cannot do a smart stream, a fallback is made to the generic
1658
repository._get_stream() interface, via self._real_stream.
1660
In the event of stacking, streams from _get_stream will not
1661
contain all the data for search - this is normal (see get_stream).
1663
:param repo: A repository.
1664
:param search: A search.
1666
# Fallbacks may be non-smart
1667
if not isinstance(repo, RemoteRepository):
1668
return self._real_stream(repo, search)
1669
client = repo._client
1670
medium = client._medium
1671
if medium._is_remote_before((1, 13)):
1672
# streaming was added in 1.13
1673
return self._real_stream(repo, search)
1674
path = repo.bzrdir._path_for_remote_call(client)
1676
search_bytes = repo._serialise_search_result(search)
1677
response = repo._call_with_body_bytes_expecting_body(
1678
'Repository.get_stream',
1679
(path, self.to_format.network_name()), search_bytes)
1680
response_tuple, response_handler = response
1681
except errors.UnknownSmartMethod:
1682
medium._remember_remote_is_before((1,13))
1683
return self._real_stream(repo, search)
1684
if response_tuple[0] != 'ok':
1685
raise errors.UnexpectedSmartServerResponse(response_tuple)
1686
byte_stream = response_handler.read_streamed_body()
1687
src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
1688
if src_format.network_name() != repo._format.network_name():
1689
raise AssertionError(
1690
"Mismatched RemoteRepository and stream src %r, %r" % (
1691
src_format.network_name(), repo._format.network_name()))
1694
def missing_parents_chain(self, search, sources):
1695
"""Chain multiple streams together to handle stacking.
1697
:param search: The overall search to satisfy with streams.
1698
:param sources: A list of Repository objects to query.
1700
self.serialiser = self.to_format._serializer
1701
self.seen_revs = set()
1702
self.referenced_revs = set()
1703
# If there are heads in the search, or the key count is > 0, we are not
1705
while not search.is_empty() and len(sources) > 1:
1706
source = sources.pop(0)
1707
stream = self._get_stream(source, search)
1708
for kind, substream in stream:
1709
if kind != 'revisions':
1710
yield kind, substream
1712
yield kind, self.missing_parents_rev_handler(substream)
1713
search = search.refine(self.seen_revs, self.referenced_revs)
1714
self.seen_revs = set()
1715
self.referenced_revs = set()
1716
if not search.is_empty():
1717
for kind, stream in self._get_stream(sources[0], search):
1720
def missing_parents_rev_handler(self, substream):
1721
for content in substream:
1722
revision_bytes = content.get_bytes_as('fulltext')
1723
revision = self.serialiser.read_revision_from_string(revision_bytes)
1724
self.seen_revs.add(content.key[-1])
1725
self.referenced_revs.update(revision.parent_ids)
1729
class RemoteBranchLockableFiles(LockableFiles):
1730
"""A 'LockableFiles' implementation that talks to a smart server.
1732
This is not a public interface class.
1735
def __init__(self, bzrdir, _client):
1736
self.bzrdir = bzrdir
1737
self._client = _client
1738
self._need_find_modes = True
1739
LockableFiles.__init__(
1740
self, bzrdir.get_branch_transport(None),
1741
'lock', lockdir.LockDir)
1743
def _find_modes(self):
1744
# RemoteBranches don't let the client set the mode of control files.
1745
self._dir_mode = None
1746
self._file_mode = None
1749
class RemoteBranchFormat(branch.BranchFormat):
1751
def __init__(self, network_name=None):
1752
super(RemoteBranchFormat, self).__init__()
1753
self._matchingbzrdir = RemoteBzrDirFormat()
1754
self._matchingbzrdir.set_branch_format(self)
1755
self._custom_format = None
1756
self._network_name = network_name
1758
def __eq__(self, other):
1759
return (isinstance(other, RemoteBranchFormat) and
1760
self.__dict__ == other.__dict__)
1762
def _ensure_real(self):
1763
if self._custom_format is None:
1764
self._custom_format = branch.network_format_registry.get(
1767
def get_format_description(self):
1768
return 'Remote BZR Branch'
1770
def network_name(self):
1771
return self._network_name
1773
def open(self, a_bzrdir, ignore_fallbacks=False):
1774
return a_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
1776
def _vfs_initialize(self, a_bzrdir):
1777
# Initialisation when using a local bzrdir object, or a non-vfs init
1778
# method is not available on the server.
1779
# self._custom_format is always set - the start of initialize ensures
1781
if isinstance(a_bzrdir, RemoteBzrDir):
1782
a_bzrdir._ensure_real()
1783
result = self._custom_format.initialize(a_bzrdir._real_bzrdir)
1785
# We assume the bzrdir is parameterised; it may not be.
1786
result = self._custom_format.initialize(a_bzrdir)
1787
if (isinstance(a_bzrdir, RemoteBzrDir) and
1788
not isinstance(result, RemoteBranch)):
1789
result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result)
1792
def initialize(self, a_bzrdir):
1793
# 1) get the network name to use.
1794
if self._custom_format:
1795
network_name = self._custom_format.network_name()
1797
# Select the current bzrlib default and ask for that.
1798
reference_bzrdir_format = bzrdir.format_registry.get('default')()
1799
reference_format = reference_bzrdir_format.get_branch_format()
1800
self._custom_format = reference_format
1801
network_name = reference_format.network_name()
1802
# Being asked to create on a non RemoteBzrDir:
1803
if not isinstance(a_bzrdir, RemoteBzrDir):
1804
return self._vfs_initialize(a_bzrdir)
1805
medium = a_bzrdir._client._medium
1806
if medium._is_remote_before((1, 13)):
1807
return self._vfs_initialize(a_bzrdir)
1808
# Creating on a remote bzr dir.
1809
# 2) try direct creation via RPC
1810
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
1811
verb = 'BzrDir.create_branch'
1813
response = a_bzrdir._call(verb, path, network_name)
1814
except errors.UnknownSmartMethod:
1815
# Fallback - use vfs methods
1816
medium._remember_remote_is_before((1, 13))
1817
return self._vfs_initialize(a_bzrdir)
1818
if response[0] != 'ok':
1819
raise errors.UnexpectedSmartServerResponse(response)
1820
# Turn the response into a RemoteRepository object.
1821
format = RemoteBranchFormat(network_name=response[1])
1822
repo_format = response_tuple_to_repo_format(response[3:])
1823
if response[2] == '':
1824
repo_bzrdir = a_bzrdir
1826
repo_bzrdir = RemoteBzrDir(
1827
a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
1829
remote_repo = RemoteRepository(repo_bzrdir, repo_format)
1830
remote_branch = RemoteBranch(a_bzrdir, remote_repo,
1831
format=format, setup_stacking=False)
1832
# XXX: We know this is a new branch, so it must have revno 0, revid
1833
# NULL_REVISION. Creating the branch locked would make this be unable
1834
# to be wrong; here its simply very unlikely to be wrong. RBC 20090225
1835
remote_branch._last_revision_info_cache = 0, NULL_REVISION
1836
return remote_branch
1838
def make_tags(self, branch):
1840
return self._custom_format.make_tags(branch)
1842
def supports_tags(self):
1843
# Remote branches might support tags, but we won't know until we
1844
# access the real remote branch.
1846
return self._custom_format.supports_tags()
1848
def supports_stacking(self):
1850
return self._custom_format.supports_stacking()
1853
class RemoteBranch(branch.Branch, _RpcHelper):
1854
"""Branch stored on a server accessed by HPSS RPC.
1856
At the moment most operations are mapped down to simple file operations.
1859
def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
1860
_client=None, format=None, setup_stacking=True):
1861
"""Create a RemoteBranch instance.
1863
:param real_branch: An optional local implementation of the branch
1864
format, usually accessing the data via the VFS.
1865
:param _client: Private parameter for testing.
1866
:param format: A RemoteBranchFormat object, None to create one
1867
automatically. If supplied it should have a network_name already
1869
:param setup_stacking: If True make an RPC call to determine the
1870
stacked (or not) status of the branch. If False assume the branch
1873
# We intentionally don't call the parent class's __init__, because it
1874
# will try to assign to self.tags, which is a property in this subclass.
1875
# And the parent's __init__ doesn't do much anyway.
1876
self._revision_id_to_revno_cache = None
1877
self._partial_revision_id_to_revno_cache = {}
1878
self._revision_history_cache = None
1879
self._last_revision_info_cache = None
1880
self._merge_sorted_revisions_cache = None
1881
self.bzrdir = remote_bzrdir
1882
if _client is not None:
1883
self._client = _client
1885
self._client = remote_bzrdir._client
1886
self.repository = remote_repository
1887
if real_branch is not None:
1888
self._real_branch = real_branch
1889
# Give the remote repository the matching real repo.
1890
real_repo = self._real_branch.repository
1891
if isinstance(real_repo, RemoteRepository):
1892
real_repo._ensure_real()
1893
real_repo = real_repo._real_repository
1894
self.repository._set_real_repository(real_repo)
1895
# Give the branch the remote repository to let fast-pathing happen.
1896
self._real_branch.repository = self.repository
1898
self._real_branch = None
1899
# Fill out expected attributes of branch for bzrlib api users.
1900
self.base = self.bzrdir.root_transport.base
1901
self._control_files = None
1902
self._lock_mode = None
1903
self._lock_token = None
1904
self._repo_lock_token = None
1905
self._lock_count = 0
1906
self._leave_lock = False
1907
# Setup a format: note that we cannot call _ensure_real until all the
1908
# attributes above are set: This code cannot be moved higher up in this
1911
self._format = RemoteBranchFormat()
1912
if real_branch is not None:
1913
self._format._network_name = \
1914
self._real_branch._format.network_name()
1916
self._format = format
1917
if not self._format._network_name:
1918
# Did not get from open_branchV2 - old server.
1920
self._format._network_name = \
1921
self._real_branch._format.network_name()
1922
self.tags = self._format.make_tags(self)
1923
# The base class init is not called, so we duplicate this:
1924
hooks = branch.Branch.hooks['open']
1928
self._setup_stacking()
1930
def _setup_stacking(self):
1931
# configure stacking into the remote repository, by reading it from
1934
fallback_url = self.get_stacked_on_url()
1935
except (errors.NotStacked, errors.UnstackableBranchFormat,
1936
errors.UnstackableRepositoryFormat), e:
1938
self._activate_fallback_location(fallback_url)
1940
def _get_config(self):
1941
return RemoteBranchConfig(self)
1943
def _get_real_transport(self):
1944
# if we try vfs access, return the real branch's vfs transport
1946
return self._real_branch._transport
1948
_transport = property(_get_real_transport)
1951
return "%s(%s)" % (self.__class__.__name__, self.base)
1955
def _ensure_real(self):
1956
"""Ensure that there is a _real_branch set.
1958
Used before calls to self._real_branch.
1960
if self._real_branch is None:
1961
if not vfs.vfs_enabled():
1962
raise AssertionError('smart server vfs must be enabled '
1963
'to use vfs implementation')
1964
self.bzrdir._ensure_real()
1965
self._real_branch = self.bzrdir._real_bzrdir.open_branch()
1966
if self.repository._real_repository is None:
1967
# Give the remote repository the matching real repo.
1968
real_repo = self._real_branch.repository
1969
if isinstance(real_repo, RemoteRepository):
1970
real_repo._ensure_real()
1971
real_repo = real_repo._real_repository
1972
self.repository._set_real_repository(real_repo)
1973
# Give the real branch the remote repository to let fast-pathing
1975
self._real_branch.repository = self.repository
1976
if self._lock_mode == 'r':
1977
self._real_branch.lock_read()
1978
elif self._lock_mode == 'w':
1979
self._real_branch.lock_write(token=self._lock_token)
1981
def _translate_error(self, err, **context):
1982
self.repository._translate_error(err, branch=self, **context)
1984
def _clear_cached_state(self):
1985
super(RemoteBranch, self)._clear_cached_state()
1986
if self._real_branch is not None:
1987
self._real_branch._clear_cached_state()
1989
def _clear_cached_state_of_remote_branch_only(self):
1990
"""Like _clear_cached_state, but doesn't clear the cache of
1993
This is useful when falling back to calling a method of
1994
self._real_branch that changes state. In that case the underlying
1995
branch changes, so we need to invalidate this RemoteBranch's cache of
1996
it. However, there's no need to invalidate the _real_branch's cache
1997
too, in fact doing so might harm performance.
1999
super(RemoteBranch, self)._clear_cached_state()
2002
def control_files(self):
2003
# Defer actually creating RemoteBranchLockableFiles until its needed,
2004
# because it triggers an _ensure_real that we otherwise might not need.
2005
if self._control_files is None:
2006
self._control_files = RemoteBranchLockableFiles(
2007
self.bzrdir, self._client)
2008
return self._control_files
2010
def _get_checkout_format(self):
2012
return self._real_branch._get_checkout_format()
2014
def get_physical_lock_status(self):
2015
"""See Branch.get_physical_lock_status()."""
2016
# should be an API call to the server, as branches must be lockable.
2018
return self._real_branch.get_physical_lock_status()
2020
def get_stacked_on_url(self):
2021
"""Get the URL this branch is stacked against.
2023
:raises NotStacked: If the branch is not stacked.
2024
:raises UnstackableBranchFormat: If the branch does not support
2026
:raises UnstackableRepositoryFormat: If the repository does not support
2030
# there may not be a repository yet, so we can't use
2031
# self._translate_error, so we can't use self._call either.
2032
response = self._client.call('Branch.get_stacked_on_url',
2033
self._remote_path())
2034
except errors.ErrorFromSmartServer, err:
2035
# there may not be a repository yet, so we can't call through
2036
# its _translate_error
2037
_translate_error(err, branch=self)
2038
except errors.UnknownSmartMethod, err:
2040
return self._real_branch.get_stacked_on_url()
2041
if response[0] != 'ok':
2042
raise errors.UnexpectedSmartServerResponse(response)
2045
def _vfs_get_tags_bytes(self):
2047
return self._real_branch._get_tags_bytes()
2049
def _get_tags_bytes(self):
2050
medium = self._client._medium
2051
if medium._is_remote_before((1, 13)):
2052
return self._vfs_get_tags_bytes()
2054
response = self._call('Branch.get_tags_bytes', self._remote_path())
2055
except errors.UnknownSmartMethod:
2056
medium._remember_remote_is_before((1, 13))
2057
return self._vfs_get_tags_bytes()
2060
def lock_read(self):
2061
self.repository.lock_read()
2062
if not self._lock_mode:
2063
self._lock_mode = 'r'
2064
self._lock_count = 1
2065
if self._real_branch is not None:
2066
self._real_branch.lock_read()
2068
self._lock_count += 1
2070
def _remote_lock_write(self, token):
2072
branch_token = repo_token = ''
2074
branch_token = token
2075
repo_token = self.repository.lock_write()
2076
self.repository.unlock()
2077
err_context = {'token': token}
2078
response = self._call(
2079
'Branch.lock_write', self._remote_path(), branch_token,
2080
repo_token or '', **err_context)
2081
if response[0] != 'ok':
2082
raise errors.UnexpectedSmartServerResponse(response)
2083
ok, branch_token, repo_token = response
2084
return branch_token, repo_token
2086
def lock_write(self, token=None):
2087
if not self._lock_mode:
2088
# Lock the branch and repo in one remote call.
2089
remote_tokens = self._remote_lock_write(token)
2090
self._lock_token, self._repo_lock_token = remote_tokens
2091
if not self._lock_token:
2092
raise SmartProtocolError('Remote server did not return a token!')
2093
# Tell the self.repository object that it is locked.
2094
self.repository.lock_write(
2095
self._repo_lock_token, _skip_rpc=True)
2097
if self._real_branch is not None:
2098
self._real_branch.lock_write(token=self._lock_token)
2099
if token is not None:
2100
self._leave_lock = True
2102
self._leave_lock = False
2103
self._lock_mode = 'w'
2104
self._lock_count = 1
2105
elif self._lock_mode == 'r':
2106
raise errors.ReadOnlyTransaction
2108
if token is not None:
2109
# A token was given to lock_write, and we're relocking, so
2110
# check that the given token actually matches the one we
2112
if token != self._lock_token:
2113
raise errors.TokenMismatch(token, self._lock_token)
2114
self._lock_count += 1
2115
# Re-lock the repository too.
2116
self.repository.lock_write(self._repo_lock_token)
2117
return self._lock_token or None
2119
def _set_tags_bytes(self, bytes):
2121
return self._real_branch._set_tags_bytes(bytes)
2123
def _unlock(self, branch_token, repo_token):
2124
err_context = {'token': str((branch_token, repo_token))}
2125
response = self._call(
2126
'Branch.unlock', self._remote_path(), branch_token,
2127
repo_token or '', **err_context)
2128
if response == ('ok',):
2130
raise errors.UnexpectedSmartServerResponse(response)
2134
self._lock_count -= 1
2135
if not self._lock_count:
2136
self._clear_cached_state()
2137
mode = self._lock_mode
2138
self._lock_mode = None
2139
if self._real_branch is not None:
2140
if (not self._leave_lock and mode == 'w' and
2141
self._repo_lock_token):
2142
# If this RemoteBranch will remove the physical lock
2143
# for the repository, make sure the _real_branch
2144
# doesn't do it first. (Because the _real_branch's
2145
# repository is set to be the RemoteRepository.)
2146
self._real_branch.repository.leave_lock_in_place()
2147
self._real_branch.unlock()
2149
# Only write-locked branched need to make a remote method
2150
# call to perfom the unlock.
2152
if not self._lock_token:
2153
raise AssertionError('Locked, but no token!')
2154
branch_token = self._lock_token
2155
repo_token = self._repo_lock_token
2156
self._lock_token = None
2157
self._repo_lock_token = None
2158
if not self._leave_lock:
2159
self._unlock(branch_token, repo_token)
2161
self.repository.unlock()
2163
def break_lock(self):
2165
return self._real_branch.break_lock()
2167
def leave_lock_in_place(self):
2168
if not self._lock_token:
2169
raise NotImplementedError(self.leave_lock_in_place)
2170
self._leave_lock = True
2172
def dont_leave_lock_in_place(self):
2173
if not self._lock_token:
2174
raise NotImplementedError(self.dont_leave_lock_in_place)
2175
self._leave_lock = False
2177
def _last_revision_info(self):
2178
response = self._call('Branch.last_revision_info', self._remote_path())
2179
if response[0] != 'ok':
2180
raise SmartProtocolError('unexpected response code %s' % (response,))
2181
revno = int(response[1])
2182
last_revision = response[2]
2183
return (revno, last_revision)
2185
def _gen_revision_history(self):
2186
"""See Branch._gen_revision_history()."""
2187
response_tuple, response_handler = self._call_expecting_body(
2188
'Branch.revision_history', self._remote_path())
2189
if response_tuple[0] != 'ok':
2190
raise errors.UnexpectedSmartServerResponse(response_tuple)
2191
result = response_handler.read_body_bytes().split('\x00')
2196
def _remote_path(self):
2197
return self.bzrdir._path_for_remote_call(self._client)
2199
def _set_last_revision_descendant(self, revision_id, other_branch,
2200
allow_diverged=False, allow_overwrite_descendant=False):
2201
# This performs additional work to meet the hook contract; while its
2202
# undesirable, we have to synthesise the revno to call the hook, and
2203
# not calling the hook is worse as it means changes can't be prevented.
2204
# Having calculated this though, we can't just call into
2205
# set_last_revision_info as a simple call, because there is a set_rh
2206
# hook that some folk may still be using.
2207
old_revno, old_revid = self.last_revision_info()
2208
history = self._lefthand_history(revision_id)
2209
self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2210
err_context = {'other_branch': other_branch}
2211
response = self._call('Branch.set_last_revision_ex',
2212
self._remote_path(), self._lock_token, self._repo_lock_token,
2213
revision_id, int(allow_diverged), int(allow_overwrite_descendant),
2215
self._clear_cached_state()
2216
if len(response) != 3 and response[0] != 'ok':
2217
raise errors.UnexpectedSmartServerResponse(response)
2218
new_revno, new_revision_id = response[1:]
2219
self._last_revision_info_cache = new_revno, new_revision_id
2220
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2221
if self._real_branch is not None:
2222
cache = new_revno, new_revision_id
2223
self._real_branch._last_revision_info_cache = cache
2225
def _set_last_revision(self, revision_id):
2226
old_revno, old_revid = self.last_revision_info()
2227
# This performs additional work to meet the hook contract; while its
2228
# undesirable, we have to synthesise the revno to call the hook, and
2229
# not calling the hook is worse as it means changes can't be prevented.
2230
# Having calculated this though, we can't just call into
2231
# set_last_revision_info as a simple call, because there is a set_rh
2232
# hook that some folk may still be using.
2233
history = self._lefthand_history(revision_id)
2234
self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2235
self._clear_cached_state()
2236
response = self._call('Branch.set_last_revision',
2237
self._remote_path(), self._lock_token, self._repo_lock_token,
2239
if response != ('ok',):
2240
raise errors.UnexpectedSmartServerResponse(response)
2241
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2244
def set_revision_history(self, rev_history):
2245
# Send just the tip revision of the history; the server will generate
2246
# the full history from that. If the revision doesn't exist in this
2247
# branch, NoSuchRevision will be raised.
2248
if rev_history == []:
2251
rev_id = rev_history[-1]
2252
self._set_last_revision(rev_id)
2253
for hook in branch.Branch.hooks['set_rh']:
2254
hook(self, rev_history)
2255
self._cache_revision_history(rev_history)
2257
def _get_parent_location(self):
2258
medium = self._client._medium
2259
if medium._is_remote_before((1, 13)):
2260
return self._vfs_get_parent_location()
2262
response = self._call('Branch.get_parent', self._remote_path())
2263
except errors.UnknownSmartMethod:
2264
medium._remember_remote_is_before((1, 13))
2265
return self._vfs_get_parent_location()
2266
if len(response) != 1:
2267
raise errors.UnexpectedSmartServerResponse(response)
2268
parent_location = response[0]
2269
if parent_location == '':
2271
return parent_location
2273
def _vfs_get_parent_location(self):
2275
return self._real_branch._get_parent_location()
2277
def set_parent(self, url):
2279
return self._real_branch.set_parent(url)
2281
def _set_parent_location(self, url):
2282
# Used by tests, to poke bad urls into branch configurations
2284
self.set_parent(url)
2287
return self._real_branch._set_parent_location(url)
2290
def pull(self, source, overwrite=False, stop_revision=None,
2292
self._clear_cached_state_of_remote_branch_only()
2294
return self._real_branch.pull(
2295
source, overwrite=overwrite, stop_revision=stop_revision,
2296
_override_hook_target=self, **kwargs)
2299
def push(self, target, overwrite=False, stop_revision=None):
2301
return self._real_branch.push(
2302
target, overwrite=overwrite, stop_revision=stop_revision,
2303
_override_hook_source_branch=self)
2305
def is_locked(self):
2306
return self._lock_count >= 1
2309
def revision_id_to_revno(self, revision_id):
2311
return self._real_branch.revision_id_to_revno(revision_id)
2314
def set_last_revision_info(self, revno, revision_id):
2315
# XXX: These should be returned by the set_last_revision_info verb
2316
old_revno, old_revid = self.last_revision_info()
2317
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2318
revision_id = ensure_null(revision_id)
2320
response = self._call('Branch.set_last_revision_info',
2321
self._remote_path(), self._lock_token, self._repo_lock_token,
2322
str(revno), revision_id)
2323
except errors.UnknownSmartMethod:
2325
self._clear_cached_state_of_remote_branch_only()
2326
self._real_branch.set_last_revision_info(revno, revision_id)
2327
self._last_revision_info_cache = revno, revision_id
2329
if response == ('ok',):
2330
self._clear_cached_state()
2331
self._last_revision_info_cache = revno, revision_id
2332
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2333
# Update the _real_branch's cache too.
2334
if self._real_branch is not None:
2335
cache = self._last_revision_info_cache
2336
self._real_branch._last_revision_info_cache = cache
2338
raise errors.UnexpectedSmartServerResponse(response)
2341
def generate_revision_history(self, revision_id, last_rev=None,
2343
medium = self._client._medium
2344
if not medium._is_remote_before((1, 6)):
2345
# Use a smart method for 1.6 and above servers
2347
self._set_last_revision_descendant(revision_id, other_branch,
2348
allow_diverged=True, allow_overwrite_descendant=True)
2350
except errors.UnknownSmartMethod:
2351
medium._remember_remote_is_before((1, 6))
2352
self._clear_cached_state_of_remote_branch_only()
2353
self.set_revision_history(self._lefthand_history(revision_id,
2354
last_rev=last_rev,other_branch=other_branch))
2356
def set_push_location(self, location):
2358
return self._real_branch.set_push_location(location)
2361
class RemoteBranchConfig(object):
2362
"""A Config that reads from a smart branch and writes via smart methods.
2364
It is a low-level object that considers config data to be name/value pairs
2365
that may be associated with a section. Assigning meaning to the these
2366
values is done at higher levels like bzrlib.config.TreeConfig.
2369
def __init__(self, branch):
2370
self._branch = branch
2372
def get_option(self, name, section=None, default=None):
2373
"""Return the value associated with a named option.
2375
:param name: The name of the value
2376
:param section: The section the option is in (if any)
2377
:param default: The value to return if the value is not set
2378
:return: The value or default value
2380
configobj = self._get_configobj()
2382
section_obj = configobj
2385
section_obj = configobj[section]
2388
return section_obj.get(name, default)
2390
def _get_configobj(self):
2391
path = self._branch._remote_path()
2392
response = self._branch._client.call_expecting_body(
2393
'Branch.get_config_file', path)
2394
if response[0][0] != 'ok':
2395
raise UnexpectedSmartServerResponse(response)
2396
bytes = response[1].read_body_bytes()
2397
return config.ConfigObj([bytes], encoding='utf-8')
2399
def set_option(self, value, name, section=None):
2400
"""Set the value associated with a named option.
2402
:param value: The value to set
2403
:param name: The name of the value to set
2404
:param section: The section the option is in (if any)
2406
medium = self._branch._client._medium
2407
if medium._is_remote_before((1, 14)):
2408
return self._vfs_set_option(value, name, section)
2410
path = self._branch._remote_path()
2411
response = self._branch._client.call('Branch.set_config_option',
2412
path, self._branch._lock_token, self._branch._repo_lock_token,
2413
value.encode('utf8'), name, section or '')
2414
except errors.UnknownSmartMethod:
2415
medium._remember_remote_is_before((1, 14))
2416
return self._vfs_set_option(value, name, section)
2418
raise errors.UnexpectedSmartServerResponse(response)
2420
def _vfs_set_option(self, value, name, section=None):
2421
self._branch._ensure_real()
2422
return self._branch._real_branch._get_config().set_option(
2423
value, name, section)
2426
def _extract_tar(tar, to_dir):
2427
"""Extract all the contents of a tarfile object.
2429
A replacement for extractall, which is not present in python2.4
2432
tar.extract(tarinfo, to_dir)
2435
def _translate_error(err, **context):
2436
"""Translate an ErrorFromSmartServer into a more useful error.
2438
Possible context keys:
2446
If the error from the server doesn't match a known pattern, then
2447
UnknownErrorFromSmartServer is raised.
2451
return context[name]
2452
except KeyError, key_err:
2453
mutter('Missing key %r in context %r', key_err.args[0], context)
2456
"""Get the path from the context if present, otherwise use first error
2460
return context['path']
2461
except KeyError, key_err:
2463
return err.error_args[0]
2464
except IndexError, idx_err:
2466
'Missing key %r in context %r', key_err.args[0], context)
2469
if err.error_verb == 'NoSuchRevision':
2470
raise NoSuchRevision(find('branch'), err.error_args[0])
2471
elif err.error_verb == 'nosuchrevision':
2472
raise NoSuchRevision(find('repository'), err.error_args[0])
2473
elif err.error_tuple == ('nobranch',):
2474
raise errors.NotBranchError(path=find('bzrdir').root_transport.base)
2475
elif err.error_verb == 'norepository':
2476
raise errors.NoRepositoryPresent(find('bzrdir'))
2477
elif err.error_verb == 'LockContention':
2478
raise errors.LockContention('(remote lock)')
2479
elif err.error_verb == 'UnlockableTransport':
2480
raise errors.UnlockableTransport(find('bzrdir').root_transport)
2481
elif err.error_verb == 'LockFailed':
2482
raise errors.LockFailed(err.error_args[0], err.error_args[1])
2483
elif err.error_verb == 'TokenMismatch':
2484
raise errors.TokenMismatch(find('token'), '(remote token)')
2485
elif err.error_verb == 'Diverged':
2486
raise errors.DivergedBranches(find('branch'), find('other_branch'))
2487
elif err.error_verb == 'TipChangeRejected':
2488
raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
2489
elif err.error_verb == 'UnstackableBranchFormat':
2490
raise errors.UnstackableBranchFormat(*err.error_args)
2491
elif err.error_verb == 'UnstackableRepositoryFormat':
2492
raise errors.UnstackableRepositoryFormat(*err.error_args)
2493
elif err.error_verb == 'NotStacked':
2494
raise errors.NotStacked(branch=find('branch'))
2495
elif err.error_verb == 'PermissionDenied':
2497
if len(err.error_args) >= 2:
2498
extra = err.error_args[1]
2501
raise errors.PermissionDenied(path, extra=extra)
2502
elif err.error_verb == 'ReadError':
2504
raise errors.ReadError(path)
2505
elif err.error_verb == 'NoSuchFile':
2507
raise errors.NoSuchFile(path)
2508
elif err.error_verb == 'FileExists':
2509
raise errors.FileExists(err.error_args[0])
2510
elif err.error_verb == 'DirectoryNotEmpty':
2511
raise errors.DirectoryNotEmpty(err.error_args[0])
2512
elif err.error_verb == 'ShortReadvError':
2513
args = err.error_args
2514
raise errors.ShortReadvError(
2515
args[0], int(args[1]), int(args[2]), int(args[3]))
2516
elif err.error_verb in ('UnicodeEncodeError', 'UnicodeDecodeError'):
2517
encoding = str(err.error_args[0]) # encoding must always be a string
2518
val = err.error_args[1]
2519
start = int(err.error_args[2])
2520
end = int(err.error_args[3])
2521
reason = str(err.error_args[4]) # reason must always be a string
2522
if val.startswith('u:'):
2523
val = val[2:].decode('utf-8')
2524
elif val.startswith('s:'):
2525
val = val[2:].decode('base64')
2526
if err.error_verb == 'UnicodeDecodeError':
2527
raise UnicodeDecodeError(encoding, val, start, end, reason)
2528
elif err.error_verb == 'UnicodeEncodeError':
2529
raise UnicodeEncodeError(encoding, val, start, end, reason)
2530
elif err.error_verb == 'ReadOnlyError':
2531
raise errors.TransportNotPossible('readonly transport')
2532
raise errors.UnknownErrorFromSmartServer(err)
added
removed
bzrlib/remote.py
