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):
396
return RemoteBzrDirConfig(self)
399
class RemoteRepositoryFormat(repository.RepositoryFormat):
400
"""Format for repositories accessed over a _SmartClient.
402
Instances of this repository are represented by RemoteRepository
405
The RemoteRepositoryFormat is parameterized during construction
406
to reflect the capabilities of the real, remote format. Specifically
407
the attributes rich_root_data and supports_tree_reference are set
408
on a per instance basis, and are not set (and should not be) at
411
:ivar _custom_format: If set, a specific concrete repository format that
412
will be used when initializing a repository with this
413
RemoteRepositoryFormat.
414
:ivar _creating_repo: If set, the repository object that this
415
RemoteRepositoryFormat was created for: it can be called into
416
to obtain data like the network name.
419
_matchingbzrdir = RemoteBzrDirFormat()
422
repository.RepositoryFormat.__init__(self)
423
self._custom_format = None
424
self._network_name = None
425
self._creating_bzrdir = None
426
self._supports_external_lookups = None
427
self._supports_tree_reference = None
428
self._rich_root_data = None
431
def fast_deltas(self):
433
return self._custom_format.fast_deltas
436
def rich_root_data(self):
437
if self._rich_root_data is None:
439
self._rich_root_data = self._custom_format.rich_root_data
440
return self._rich_root_data
443
def supports_external_lookups(self):
444
if self._supports_external_lookups is None:
446
self._supports_external_lookups = \
447
self._custom_format.supports_external_lookups
448
return self._supports_external_lookups
451
def supports_tree_reference(self):
452
if self._supports_tree_reference is None:
454
self._supports_tree_reference = \
455
self._custom_format.supports_tree_reference
456
return self._supports_tree_reference
458
def _vfs_initialize(self, a_bzrdir, shared):
459
"""Helper for common code in initialize."""
460
if self._custom_format:
461
# Custom format requested
462
result = self._custom_format.initialize(a_bzrdir, shared=shared)
463
elif self._creating_bzrdir is not None:
464
# Use the format that the repository we were created to back
466
prior_repo = self._creating_bzrdir.open_repository()
467
prior_repo._ensure_real()
468
result = prior_repo._real_repository._format.initialize(
469
a_bzrdir, shared=shared)
471
# assume that a_bzr is a RemoteBzrDir but the smart server didn't
472
# support remote initialization.
473
# We delegate to a real object at this point (as RemoteBzrDir
474
# delegate to the repository format which would lead to infinite
475
# recursion if we just called a_bzrdir.create_repository.
476
a_bzrdir._ensure_real()
477
result = a_bzrdir._real_bzrdir.create_repository(shared=shared)
478
if not isinstance(result, RemoteRepository):
479
return self.open(a_bzrdir)
483
def initialize(self, a_bzrdir, shared=False):
484
# Being asked to create on a non RemoteBzrDir:
485
if not isinstance(a_bzrdir, RemoteBzrDir):
486
return self._vfs_initialize(a_bzrdir, shared)
487
medium = a_bzrdir._client._medium
488
if medium._is_remote_before((1, 13)):
489
return self._vfs_initialize(a_bzrdir, shared)
490
# Creating on a remote bzr dir.
491
# 1) get the network name to use.
492
if self._custom_format:
493
network_name = self._custom_format.network_name()
495
# Select the current bzrlib default and ask for that.
496
reference_bzrdir_format = bzrdir.format_registry.get('default')()
497
reference_format = reference_bzrdir_format.repository_format
498
network_name = reference_format.network_name()
499
# 2) try direct creation via RPC
500
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
501
verb = 'BzrDir.create_repository'
507
response = a_bzrdir._call(verb, path, network_name, shared_str)
508
except errors.UnknownSmartMethod:
509
# Fallback - use vfs methods
510
medium._remember_remote_is_before((1, 13))
511
return self._vfs_initialize(a_bzrdir, shared)
513
# Turn the response into a RemoteRepository object.
514
format = response_tuple_to_repo_format(response[1:])
515
# Used to support creating a real format instance when needed.
516
format._creating_bzrdir = a_bzrdir
517
remote_repo = RemoteRepository(a_bzrdir, format)
518
format._creating_repo = remote_repo
521
def open(self, a_bzrdir):
522
if not isinstance(a_bzrdir, RemoteBzrDir):
523
raise AssertionError('%r is not a RemoteBzrDir' % (a_bzrdir,))
524
return a_bzrdir.open_repository()
526
def _ensure_real(self):
527
if self._custom_format is None:
528
self._custom_format = repository.network_format_registry.get(
532
def _fetch_order(self):
534
return self._custom_format._fetch_order
537
def _fetch_uses_deltas(self):
539
return self._custom_format._fetch_uses_deltas
542
def _fetch_reconcile(self):
544
return self._custom_format._fetch_reconcile
546
def get_format_description(self):
547
return 'bzr remote repository'
549
def __eq__(self, other):
550
return self.__class__ is other.__class__
552
def check_conversion_target(self, target_format):
553
if self.rich_root_data and not target_format.rich_root_data:
554
raise errors.BadConversionTarget(
555
'Does not support rich root data.', target_format)
556
if (self.supports_tree_reference and
557
not getattr(target_format, 'supports_tree_reference', False)):
558
raise errors.BadConversionTarget(
559
'Does not support nested trees', target_format)
561
def network_name(self):
562
if self._network_name:
563
return self._network_name
564
self._creating_repo._ensure_real()
565
return self._creating_repo._real_repository._format.network_name()
568
def _serializer(self):
570
return self._custom_format._serializer
573
class RemoteRepository(_RpcHelper):
574
"""Repository accessed over rpc.
576
For the moment most operations are performed using local transport-backed
580
def __init__(self, remote_bzrdir, format, real_repository=None, _client=None):
581
"""Create a RemoteRepository instance.
583
:param remote_bzrdir: The bzrdir hosting this repository.
584
:param format: The RemoteFormat object to use.
585
:param real_repository: If not None, a local implementation of the
586
repository logic for the repository, usually accessing the data
588
:param _client: Private testing parameter - override the smart client
589
to be used by the repository.
592
self._real_repository = real_repository
594
self._real_repository = None
595
self.bzrdir = remote_bzrdir
597
self._client = remote_bzrdir._client
599
self._client = _client
600
self._format = format
601
self._lock_mode = None
602
self._lock_token = None
604
self._leave_lock = False
605
self._unstacked_provider = graph.CachingParentsProvider(
606
get_parent_map=self._get_parent_map_rpc)
607
self._unstacked_provider.disable_cache()
609
# These depend on the actual remote format, so force them off for
610
# maximum compatibility. XXX: In future these should depend on the
611
# remote repository instance, but this is irrelevant until we perform
612
# reconcile via an RPC call.
613
self._reconcile_does_inventory_gc = False
614
self._reconcile_fixes_text_parents = False
615
self._reconcile_backsup_inventory = False
616
self.base = self.bzrdir.transport.base
617
# Additional places to query for data.
618
self._fallback_repositories = []
621
return "%s(%s)" % (self.__class__.__name__, self.base)
625
def abort_write_group(self, suppress_errors=False):
626
"""Complete a write group on the decorated repository.
628
Smart methods perform operations in a single step so this API
629
is not really applicable except as a compatibility thunk
630
for older plugins that don't use e.g. the CommitBuilder
633
:param suppress_errors: see Repository.abort_write_group.
636
return self._real_repository.abort_write_group(
637
suppress_errors=suppress_errors)
641
"""Decorate the real repository for now.
643
In the long term a full blown network facility is needed to avoid
644
creating a real repository object locally.
647
return self._real_repository.chk_bytes
649
def commit_write_group(self):
650
"""Complete a write group on the decorated repository.
652
Smart methods perform operations in a single step so this API
653
is not really applicable except as a compatibility thunk
654
for older plugins that don't use e.g. the CommitBuilder
658
return self._real_repository.commit_write_group()
660
def resume_write_group(self, tokens):
662
return self._real_repository.resume_write_group(tokens)
664
def suspend_write_group(self):
666
return self._real_repository.suspend_write_group()
668
def _ensure_real(self):
669
"""Ensure that there is a _real_repository set.
671
Used before calls to self._real_repository.
673
Note that _ensure_real causes many roundtrips to the server which are
674
not desirable, and prevents the use of smart one-roundtrip RPC's to
675
perform complex operations (such as accessing parent data, streaming
676
revisions etc). Adding calls to _ensure_real should only be done when
677
bringing up new functionality, adding fallbacks for smart methods that
678
require a fallback path, and never to replace an existing smart method
679
invocation. If in doubt chat to the bzr network team.
681
if self._real_repository is None:
682
self.bzrdir._ensure_real()
683
self._set_real_repository(
684
self.bzrdir._real_bzrdir.open_repository())
686
def _translate_error(self, err, **context):
687
self.bzrdir._translate_error(err, repository=self, **context)
689
def find_text_key_references(self):
690
"""Find the text key references within the repository.
692
:return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
693
revision_ids. Each altered file-ids has the exact revision_ids that
694
altered it listed explicitly.
695
:return: A dictionary mapping text keys ((fileid, revision_id) tuples)
696
to whether they were referred to by the inventory of the
697
revision_id that they contain. The inventory texts from all present
698
revision ids are assessed to generate this report.
701
return self._real_repository.find_text_key_references()
703
def _generate_text_key_index(self):
704
"""Generate a new text key index for the repository.
706
This is an expensive function that will take considerable time to run.
708
:return: A dict mapping (file_id, revision_id) tuples to a list of
709
parents, also (file_id, revision_id) tuples.
712
return self._real_repository._generate_text_key_index()
714
def _get_revision_graph(self, revision_id):
715
"""Private method for using with old (< 1.2) servers to fallback."""
716
if revision_id is None:
718
elif revision.is_null(revision_id):
721
path = self.bzrdir._path_for_remote_call(self._client)
722
response = self._call_expecting_body(
723
'Repository.get_revision_graph', path, revision_id)
724
response_tuple, response_handler = response
725
if response_tuple[0] != 'ok':
726
raise errors.UnexpectedSmartServerResponse(response_tuple)
727
coded = response_handler.read_body_bytes()
729
# no revisions in this repository!
731
lines = coded.split('\n')
734
d = tuple(line.split())
735
revision_graph[d[0]] = d[1:]
737
return revision_graph
740
"""See Repository._get_sink()."""
741
return RemoteStreamSink(self)
743
def _get_source(self, to_format):
744
"""Return a source for streaming from this repository."""
745
return RemoteStreamSource(self, to_format)
747
def has_revision(self, revision_id):
748
"""See Repository.has_revision()."""
749
if revision_id == NULL_REVISION:
750
# The null revision is always present.
752
path = self.bzrdir._path_for_remote_call(self._client)
753
response = self._call('Repository.has_revision', path, revision_id)
754
if response[0] not in ('yes', 'no'):
755
raise errors.UnexpectedSmartServerResponse(response)
756
if response[0] == 'yes':
758
for fallback_repo in self._fallback_repositories:
759
if fallback_repo.has_revision(revision_id):
763
def has_revisions(self, revision_ids):
764
"""See Repository.has_revisions()."""
765
# FIXME: This does many roundtrips, particularly when there are
766
# fallback repositories. -- mbp 20080905
768
for revision_id in revision_ids:
769
if self.has_revision(revision_id):
770
result.add(revision_id)
773
def has_same_location(self, other):
774
return (self.__class__ is other.__class__ and
775
self.bzrdir.transport.base == other.bzrdir.transport.base)
777
def get_graph(self, other_repository=None):
778
"""Return the graph for this repository format"""
779
parents_provider = self._make_parents_provider(other_repository)
780
return graph.Graph(parents_provider)
782
def gather_stats(self, revid=None, committers=None):
783
"""See Repository.gather_stats()."""
784
path = self.bzrdir._path_for_remote_call(self._client)
785
# revid can be None to indicate no revisions, not just NULL_REVISION
786
if revid is None or revision.is_null(revid):
790
if committers is None or not committers:
791
fmt_committers = 'no'
793
fmt_committers = 'yes'
794
response_tuple, response_handler = self._call_expecting_body(
795
'Repository.gather_stats', path, fmt_revid, fmt_committers)
796
if response_tuple[0] != 'ok':
797
raise errors.UnexpectedSmartServerResponse(response_tuple)
799
body = response_handler.read_body_bytes()
801
for line in body.split('\n'):
804
key, val_text = line.split(':')
805
if key in ('revisions', 'size', 'committers'):
806
result[key] = int(val_text)
807
elif key in ('firstrev', 'latestrev'):
808
values = val_text.split(' ')[1:]
809
result[key] = (float(values[0]), long(values[1]))
813
def find_branches(self, using=False):
814
"""See Repository.find_branches()."""
815
# should be an API call to the server.
817
return self._real_repository.find_branches(using=using)
819
def get_physical_lock_status(self):
820
"""See Repository.get_physical_lock_status()."""
821
# should be an API call to the server.
823
return self._real_repository.get_physical_lock_status()
825
def is_in_write_group(self):
826
"""Return True if there is an open write group.
828
write groups are only applicable locally for the smart server..
830
if self._real_repository:
831
return self._real_repository.is_in_write_group()
834
return self._lock_count >= 1
837
"""See Repository.is_shared()."""
838
path = self.bzrdir._path_for_remote_call(self._client)
839
response = self._call('Repository.is_shared', path)
840
if response[0] not in ('yes', 'no'):
841
raise SmartProtocolError('unexpected response code %s' % (response,))
842
return response[0] == 'yes'
844
def is_write_locked(self):
845
return self._lock_mode == 'w'
848
# wrong eventually - want a local lock cache context
849
if not self._lock_mode:
850
self._lock_mode = 'r'
852
self._unstacked_provider.enable_cache(cache_misses=True)
853
if self._real_repository is not None:
854
self._real_repository.lock_read()
856
self._lock_count += 1
857
for repo in self._fallback_repositories:
860
def _remote_lock_write(self, token):
861
path = self.bzrdir._path_for_remote_call(self._client)
864
err_context = {'token': token}
865
response = self._call('Repository.lock_write', path, token,
867
if response[0] == 'ok':
871
raise errors.UnexpectedSmartServerResponse(response)
873
def lock_write(self, token=None, _skip_rpc=False):
874
if not self._lock_mode:
876
if self._lock_token is not None:
877
if token != self._lock_token:
878
raise errors.TokenMismatch(token, self._lock_token)
879
self._lock_token = token
881
self._lock_token = self._remote_lock_write(token)
882
# if self._lock_token is None, then this is something like packs or
883
# svn where we don't get to lock the repo, or a weave style repository
884
# where we cannot lock it over the wire and attempts to do so will
886
if self._real_repository is not None:
887
self._real_repository.lock_write(token=self._lock_token)
888
if token is not None:
889
self._leave_lock = True
891
self._leave_lock = False
892
self._lock_mode = 'w'
894
self._unstacked_provider.enable_cache(cache_misses=False)
895
elif self._lock_mode == 'r':
896
raise errors.ReadOnlyError(self)
898
self._lock_count += 1
899
for repo in self._fallback_repositories:
900
# Writes don't affect fallback repos
902
return self._lock_token or None
904
def leave_lock_in_place(self):
905
if not self._lock_token:
906
raise NotImplementedError(self.leave_lock_in_place)
907
self._leave_lock = True
909
def dont_leave_lock_in_place(self):
910
if not self._lock_token:
911
raise NotImplementedError(self.dont_leave_lock_in_place)
912
self._leave_lock = False
914
def _set_real_repository(self, repository):
915
"""Set the _real_repository for this repository.
917
:param repository: The repository to fallback to for non-hpss
918
implemented operations.
920
if self._real_repository is not None:
921
# Replacing an already set real repository.
922
# We cannot do this [currently] if the repository is locked -
923
# synchronised state might be lost.
925
raise AssertionError('_real_repository is already set')
926
if isinstance(repository, RemoteRepository):
927
raise AssertionError()
928
self._real_repository = repository
929
# three code paths happen here:
930
# 1) old servers, RemoteBranch.open() calls _ensure_real before setting
931
# up stacking. In this case self._fallback_repositories is [], and the
932
# real repo is already setup. Preserve the real repo and
933
# RemoteRepository.add_fallback_repository will avoid adding
935
# 2) new servers, RemoteBranch.open() sets up stacking, and when
936
# ensure_real is triggered from a branch, the real repository to
937
# set already has a matching list with separate instances, but
938
# as they are also RemoteRepositories we don't worry about making the
939
# lists be identical.
940
# 3) new servers, RemoteRepository.ensure_real is triggered before
941
# RemoteBranch.ensure real, in this case we get a repo with no fallbacks
942
# and need to populate it.
943
if (self._fallback_repositories and
944
len(self._real_repository._fallback_repositories) !=
945
len(self._fallback_repositories)):
946
if len(self._real_repository._fallback_repositories):
947
raise AssertionError(
948
"cannot cleanly remove existing _fallback_repositories")
949
for fb in self._fallback_repositories:
950
self._real_repository.add_fallback_repository(fb)
951
if self._lock_mode == 'w':
952
# if we are already locked, the real repository must be able to
953
# acquire the lock with our token.
954
self._real_repository.lock_write(self._lock_token)
955
elif self._lock_mode == 'r':
956
self._real_repository.lock_read()
958
def start_write_group(self):
959
"""Start a write group on the decorated repository.
961
Smart methods perform operations in a single step so this API
962
is not really applicable except as a compatibility thunk
963
for older plugins that don't use e.g. the CommitBuilder
967
return self._real_repository.start_write_group()
969
def _unlock(self, token):
970
path = self.bzrdir._path_for_remote_call(self._client)
972
# with no token the remote repository is not persistently locked.
974
err_context = {'token': token}
975
response = self._call('Repository.unlock', path, token,
977
if response == ('ok',):
980
raise errors.UnexpectedSmartServerResponse(response)
983
if not self._lock_count:
984
raise errors.LockNotHeld(self)
985
self._lock_count -= 1
986
if self._lock_count > 0:
988
self._unstacked_provider.disable_cache()
989
old_mode = self._lock_mode
990
self._lock_mode = None
992
# The real repository is responsible at present for raising an
993
# exception if it's in an unfinished write group. However, it
994
# normally will *not* actually remove the lock from disk - that's
995
# done by the server on receiving the Repository.unlock call.
996
# This is just to let the _real_repository stay up to date.
997
if self._real_repository is not None:
998
self._real_repository.unlock()
1000
# The rpc-level lock should be released even if there was a
1001
# problem releasing the vfs-based lock.
1003
# Only write-locked repositories need to make a remote method
1004
# call to perform the unlock.
1005
old_token = self._lock_token
1006
self._lock_token = None
1007
if not self._leave_lock:
1008
self._unlock(old_token)
1010
def break_lock(self):
1011
# should hand off to the network
1013
return self._real_repository.break_lock()
1015
def _get_tarball(self, compression):
1016
"""Return a TemporaryFile containing a repository tarball.
1018
Returns None if the server does not support sending tarballs.
1021
path = self.bzrdir._path_for_remote_call(self._client)
1023
response, protocol = self._call_expecting_body(
1024
'Repository.tarball', path, compression)
1025
except errors.UnknownSmartMethod:
1026
protocol.cancel_read_body()
1028
if response[0] == 'ok':
1029
# Extract the tarball and return it
1030
t = tempfile.NamedTemporaryFile()
1031
# TODO: rpc layer should read directly into it...
1032
t.write(protocol.read_body_bytes())
1035
raise errors.UnexpectedSmartServerResponse(response)
1037
def sprout(self, to_bzrdir, revision_id=None):
1038
# TODO: Option to control what format is created?
1040
dest_repo = self._real_repository._format.initialize(to_bzrdir,
1042
dest_repo.fetch(self, revision_id=revision_id)
1045
### These methods are just thin shims to the VFS object for now.
1047
def revision_tree(self, revision_id):
1049
return self._real_repository.revision_tree(revision_id)
1051
def get_serializer_format(self):
1053
return self._real_repository.get_serializer_format()
1055
def get_commit_builder(self, branch, parents, config, timestamp=None,
1056
timezone=None, committer=None, revprops=None,
1058
# FIXME: It ought to be possible to call this without immediately
1059
# triggering _ensure_real. For now it's the easiest thing to do.
1061
real_repo = self._real_repository
1062
builder = real_repo.get_commit_builder(branch, parents,
1063
config, timestamp=timestamp, timezone=timezone,
1064
committer=committer, revprops=revprops, revision_id=revision_id)
1067
def add_fallback_repository(self, repository):
1068
"""Add a repository to use for looking up data not held locally.
1070
:param repository: A repository.
1072
if not self._format.supports_external_lookups:
1073
raise errors.UnstackableRepositoryFormat(
1074
self._format.network_name(), self.base)
1075
# We need to accumulate additional repositories here, to pass them in
1078
self._fallback_repositories.append(repository)
1079
# If self._real_repository was parameterised already (e.g. because a
1080
# _real_branch had its get_stacked_on_url method called), then the
1081
# repository to be added may already be in the _real_repositories list.
1082
if self._real_repository is not None:
1083
fallback_locations = [repo.bzrdir.root_transport.base for repo in
1084
self._real_repository._fallback_repositories]
1085
if repository.bzrdir.root_transport.base not in fallback_locations:
1086
self._real_repository.add_fallback_repository(repository)
1088
def add_inventory(self, revid, inv, parents):
1090
return self._real_repository.add_inventory(revid, inv, parents)
1092
def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1095
return self._real_repository.add_inventory_by_delta(basis_revision_id,
1096
delta, new_revision_id, parents)
1098
def add_revision(self, rev_id, rev, inv=None, config=None):
1100
return self._real_repository.add_revision(
1101
rev_id, rev, inv=inv, config=config)
1104
def get_inventory(self, revision_id):
1106
return self._real_repository.get_inventory(revision_id)
1108
def iter_inventories(self, revision_ids):
1110
return self._real_repository.iter_inventories(revision_ids)
1113
def get_revision(self, revision_id):
1115
return self._real_repository.get_revision(revision_id)
1117
def get_transaction(self):
1119
return self._real_repository.get_transaction()
1122
def clone(self, a_bzrdir, revision_id=None):
1124
return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
1126
def make_working_trees(self):
1127
"""See Repository.make_working_trees"""
1129
return self._real_repository.make_working_trees()
1131
def refresh_data(self):
1132
"""Re-read any data needed to to synchronise with disk.
1134
This method is intended to be called after another repository instance
1135
(such as one used by a smart server) has inserted data into the
1136
repository. It may not be called during a write group, but may be
1137
called at any other time.
1139
if self.is_in_write_group():
1140
raise errors.InternalBzrError(
1141
"May not refresh_data while in a write group.")
1142
if self._real_repository is not None:
1143
self._real_repository.refresh_data()
1145
def revision_ids_to_search_result(self, result_set):
1146
"""Convert a set of revision ids to a graph SearchResult."""
1147
result_parents = set()
1148
for parents in self.get_graph().get_parent_map(
1149
result_set).itervalues():
1150
result_parents.update(parents)
1151
included_keys = result_set.intersection(result_parents)
1152
start_keys = result_set.difference(included_keys)
1153
exclude_keys = result_parents.difference(result_set)
1154
result = graph.SearchResult(start_keys, exclude_keys,
1155
len(result_set), result_set)
1159
def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1160
"""Return the revision ids that other has that this does not.
1162
These are returned in topological order.
1164
revision_id: only return revision ids included by revision_id.
1166
return repository.InterRepository.get(
1167
other, self).search_missing_revision_ids(revision_id, find_ghosts)
1169
def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
1171
# No base implementation to use as RemoteRepository is not a subclass
1172
# of Repository; so this is a copy of Repository.fetch().
1173
if fetch_spec is not None and revision_id is not None:
1174
raise AssertionError(
1175
"fetch_spec and revision_id are mutually exclusive.")
1176
if self.is_in_write_group():
1177
raise errors.InternalBzrError(
1178
"May not fetch while in a write group.")
1179
# fast path same-url fetch operations
1180
if self.has_same_location(source) and fetch_spec is None:
1181
# check that last_revision is in 'from' and then return a
1183
if (revision_id is not None and
1184
not revision.is_null(revision_id)):
1185
self.get_revision(revision_id)
1187
# if there is no specific appropriate InterRepository, this will get
1188
# the InterRepository base class, which raises an
1189
# IncompatibleRepositories when asked to fetch.
1190
inter = repository.InterRepository.get(source, self)
1191
return inter.fetch(revision_id=revision_id, pb=pb,
1192
find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1194
def create_bundle(self, target, base, fileobj, format=None):
1196
self._real_repository.create_bundle(target, base, fileobj, format)
1199
def get_ancestry(self, revision_id, topo_sorted=True):
1201
return self._real_repository.get_ancestry(revision_id, topo_sorted)
1203
def fileids_altered_by_revision_ids(self, revision_ids):
1205
return self._real_repository.fileids_altered_by_revision_ids(revision_ids)
1207
def _get_versioned_file_checker(self, revisions, revision_versions_cache):
1209
return self._real_repository._get_versioned_file_checker(
1210
revisions, revision_versions_cache)
1212
def iter_files_bytes(self, desired_files):
1213
"""See Repository.iter_file_bytes.
1216
return self._real_repository.iter_files_bytes(desired_files)
1218
def get_parent_map(self, revision_ids):
1219
"""See bzrlib.Graph.get_parent_map()."""
1220
return self._make_parents_provider().get_parent_map(revision_ids)
1222
def _get_parent_map_rpc(self, keys):
1223
"""Helper for get_parent_map that performs the RPC."""
1224
medium = self._client._medium
1225
if medium._is_remote_before((1, 2)):
1226
# We already found out that the server can't understand
1227
# Repository.get_parent_map requests, so just fetch the whole
1230
# Note that this reads the whole graph, when only some keys are
1231
# wanted. On this old server there's no way (?) to get them all
1232
# in one go, and the user probably will have seen a warning about
1233
# the server being old anyhow.
1234
rg = self._get_revision_graph(None)
1235
# There is an API discrepancy between get_parent_map and
1236
# get_revision_graph. Specifically, a "key:()" pair in
1237
# get_revision_graph just means a node has no parents. For
1238
# "get_parent_map" it means the node is a ghost. So fix up the
1239
# graph to correct this.
1240
# https://bugs.launchpad.net/bzr/+bug/214894
1241
# There is one other "bug" which is that ghosts in
1242
# get_revision_graph() are not returned at all. But we won't worry
1243
# about that for now.
1244
for node_id, parent_ids in rg.iteritems():
1245
if parent_ids == ():
1246
rg[node_id] = (NULL_REVISION,)
1247
rg[NULL_REVISION] = ()
1252
raise ValueError('get_parent_map(None) is not valid')
1253
if NULL_REVISION in keys:
1254
keys.discard(NULL_REVISION)
1255
found_parents = {NULL_REVISION:()}
1257
return found_parents
1260
# TODO(Needs analysis): We could assume that the keys being requested
1261
# from get_parent_map are in a breadth first search, so typically they
1262
# will all be depth N from some common parent, and we don't have to
1263
# have the server iterate from the root parent, but rather from the
1264
# keys we're searching; and just tell the server the keyspace we
1265
# already have; but this may be more traffic again.
1267
# Transform self._parents_map into a search request recipe.
1268
# TODO: Manage this incrementally to avoid covering the same path
1269
# repeatedly. (The server will have to on each request, but the less
1270
# work done the better).
1272
# Negative caching notes:
1273
# new server sends missing when a request including the revid
1274
# 'include-missing:' is present in the request.
1275
# missing keys are serialised as missing:X, and we then call
1276
# provider.note_missing(X) for-all X
1277
parents_map = self._unstacked_provider.get_cached_map()
1278
if parents_map is None:
1279
# Repository is not locked, so there's no cache.
1281
# start_set is all the keys in the cache
1282
start_set = set(parents_map)
1283
# result set is all the references to keys in the cache
1284
result_parents = set()
1285
for parents in parents_map.itervalues():
1286
result_parents.update(parents)
1287
stop_keys = result_parents.difference(start_set)
1288
# We don't need to send ghosts back to the server as a position to
1290
stop_keys.difference_update(self._unstacked_provider.missing_keys)
1291
key_count = len(parents_map)
1292
if (NULL_REVISION in result_parents
1293
and NULL_REVISION in self._unstacked_provider.missing_keys):
1294
# If we pruned NULL_REVISION from the stop_keys because it's also
1295
# in our cache of "missing" keys we need to increment our key count
1296
# by 1, because the reconsitituted SearchResult on the server will
1297
# still consider NULL_REVISION to be an included key.
1299
included_keys = start_set.intersection(result_parents)
1300
start_set.difference_update(included_keys)
1301
recipe = ('manual', start_set, stop_keys, key_count)
1302
body = self._serialise_search_recipe(recipe)
1303
path = self.bzrdir._path_for_remote_call(self._client)
1305
if type(key) is not str:
1307
"key %r not a plain string" % (key,))
1308
verb = 'Repository.get_parent_map'
1309
args = (path, 'include-missing:') + tuple(keys)
1311
response = self._call_with_body_bytes_expecting_body(
1313
except errors.UnknownSmartMethod:
1314
# Server does not support this method, so get the whole graph.
1315
# Worse, we have to force a disconnection, because the server now
1316
# doesn't realise it has a body on the wire to consume, so the
1317
# only way to recover is to abandon the connection.
1319
'Server is too old for fast get_parent_map, reconnecting. '
1320
'(Upgrade the server to Bazaar 1.2 to avoid this)')
1322
# To avoid having to disconnect repeatedly, we keep track of the
1323
# fact the server doesn't understand remote methods added in 1.2.
1324
medium._remember_remote_is_before((1, 2))
1325
# Recurse just once and we should use the fallback code.
1326
return self._get_parent_map_rpc(keys)
1327
response_tuple, response_handler = response
1328
if response_tuple[0] not in ['ok']:
1329
response_handler.cancel_read_body()
1330
raise errors.UnexpectedSmartServerResponse(response_tuple)
1331
if response_tuple[0] == 'ok':
1332
coded = bz2.decompress(response_handler.read_body_bytes())
1334
# no revisions found
1336
lines = coded.split('\n')
1339
d = tuple(line.split())
1341
revision_graph[d[0]] = d[1:]
1344
if d[0].startswith('missing:'):
1346
self._unstacked_provider.note_missing_key(revid)
1348
# no parents - so give the Graph result
1350
revision_graph[d[0]] = (NULL_REVISION,)
1351
return revision_graph
1354
def get_signature_text(self, revision_id):
1356
return self._real_repository.get_signature_text(revision_id)
1359
def get_inventory_xml(self, revision_id):
1361
return self._real_repository.get_inventory_xml(revision_id)
1363
def deserialise_inventory(self, revision_id, xml):
1365
return self._real_repository.deserialise_inventory(revision_id, xml)
1367
def reconcile(self, other=None, thorough=False):
1369
return self._real_repository.reconcile(other=other, thorough=thorough)
1371
def all_revision_ids(self):
1373
return self._real_repository.all_revision_ids()
1376
def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1378
return self._real_repository.get_deltas_for_revisions(revisions,
1379
specific_fileids=specific_fileids)
1382
def get_revision_delta(self, revision_id, specific_fileids=None):
1384
return self._real_repository.get_revision_delta(revision_id,
1385
specific_fileids=specific_fileids)
1388
def revision_trees(self, revision_ids):
1390
return self._real_repository.revision_trees(revision_ids)
1393
def get_revision_reconcile(self, revision_id):
1395
return self._real_repository.get_revision_reconcile(revision_id)
1398
def check(self, revision_ids=None):
1400
return self._real_repository.check(revision_ids=revision_ids)
1402
def copy_content_into(self, destination, revision_id=None):
1404
return self._real_repository.copy_content_into(
1405
destination, revision_id=revision_id)
1407
def _copy_repository_tarball(self, to_bzrdir, revision_id=None):
1408
# get a tarball of the remote repository, and copy from that into the
1410
from bzrlib import osutils
1412
# TODO: Maybe a progress bar while streaming the tarball?
1413
note("Copying repository content as tarball...")
1414
tar_file = self._get_tarball('bz2')
1415
if tar_file is None:
1417
destination = to_bzrdir.create_repository()
1419
tar = tarfile.open('repository', fileobj=tar_file,
1421
tmpdir = osutils.mkdtemp()
1423
_extract_tar(tar, tmpdir)
1424
tmp_bzrdir = BzrDir.open(tmpdir)
1425
tmp_repo = tmp_bzrdir.open_repository()
1426
tmp_repo.copy_content_into(destination, revision_id)
1428
osutils.rmtree(tmpdir)
1432
# TODO: Suggestion from john: using external tar is much faster than
1433
# python's tarfile library, but it may not work on windows.
1436
def inventories(self):
1437
"""Decorate the real repository for now.
1439
In the long term a full blown network facility is needed to
1440
avoid creating a real repository object locally.
1443
return self._real_repository.inventories
1447
"""Compress the data within the repository.
1449
This is not currently implemented within the smart server.
1452
return self._real_repository.pack()
1455
def revisions(self):
1456
"""Decorate the real repository for now.
1458
In the short term this should become a real object to intercept graph
1461
In the long term a full blown network facility is needed.
1464
return self._real_repository.revisions
1466
def set_make_working_trees(self, new_value):
1468
new_value_str = "True"
1470
new_value_str = "False"
1471
path = self.bzrdir._path_for_remote_call(self._client)
1473
response = self._call(
1474
'Repository.set_make_working_trees', path, new_value_str)
1475
except errors.UnknownSmartMethod:
1477
self._real_repository.set_make_working_trees(new_value)
1479
if response[0] != 'ok':
1480
raise errors.UnexpectedSmartServerResponse(response)
1483
def signatures(self):
1484
"""Decorate the real repository for now.
1486
In the long term a full blown network facility is needed to avoid
1487
creating a real repository object locally.
1490
return self._real_repository.signatures
1493
def sign_revision(self, revision_id, gpg_strategy):
1495
return self._real_repository.sign_revision(revision_id, gpg_strategy)
1499
"""Decorate the real repository for now.
1501
In the long term a full blown network facility is needed to avoid
1502
creating a real repository object locally.
1505
return self._real_repository.texts
1508
def get_revisions(self, revision_ids):
1510
return self._real_repository.get_revisions(revision_ids)
1512
def supports_rich_root(self):
1513
return self._format.rich_root_data
1515
def iter_reverse_revision_history(self, revision_id):
1517
return self._real_repository.iter_reverse_revision_history(revision_id)
1520
def _serializer(self):
1521
return self._format._serializer
1523
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1525
return self._real_repository.store_revision_signature(
1526
gpg_strategy, plaintext, revision_id)
1528
def add_signature_text(self, revision_id, signature):
1530
return self._real_repository.add_signature_text(revision_id, signature)
1532
def has_signature_for_revision_id(self, revision_id):
1534
return self._real_repository.has_signature_for_revision_id(revision_id)
1536
def item_keys_introduced_by(self, revision_ids, _files_pb=None):
1538
return self._real_repository.item_keys_introduced_by(revision_ids,
1539
_files_pb=_files_pb)
1541
def revision_graph_can_have_wrong_parents(self):
1542
# The answer depends on the remote repo format.
1544
return self._real_repository.revision_graph_can_have_wrong_parents()
1546
def _find_inconsistent_revision_parents(self):
1548
return self._real_repository._find_inconsistent_revision_parents()
1550
def _check_for_inconsistent_revision_parents(self):
1552
return self._real_repository._check_for_inconsistent_revision_parents()
1554
def _make_parents_provider(self, other=None):
1555
providers = [self._unstacked_provider]
1556
if other is not None:
1557
providers.insert(0, other)
1558
providers.extend(r._make_parents_provider() for r in
1559
self._fallback_repositories)
1560
return graph._StackedParentsProvider(providers)
1562
def _serialise_search_recipe(self, recipe):
1563
"""Serialise a graph search recipe.
1565
:param recipe: A search recipe (start, stop, count).
1566
:return: Serialised bytes.
1568
start_keys = ' '.join(recipe[1])
1569
stop_keys = ' '.join(recipe[2])
1570
count = str(recipe[3])
1571
return '\n'.join((start_keys, stop_keys, count))
1573
def _serialise_search_result(self, search_result):
1574
if isinstance(search_result, graph.PendingAncestryResult):
1575
parts = ['ancestry-of']
1576
parts.extend(search_result.heads)
1578
recipe = search_result.get_recipe()
1579
parts = [recipe[0], self._serialise_search_recipe(recipe)]
1580
return '\n'.join(parts)
1583
path = self.bzrdir._path_for_remote_call(self._client)
1585
response = self._call('PackRepository.autopack', path)
1586
except errors.UnknownSmartMethod:
1588
self._real_repository._pack_collection.autopack()
1591
if response[0] != 'ok':
1592
raise errors.UnexpectedSmartServerResponse(response)
1595
class RemoteStreamSink(repository.StreamSink):
1597
def _insert_real(self, stream, src_format, resume_tokens):
1598
self.target_repo._ensure_real()
1599
sink = self.target_repo._real_repository._get_sink()
1600
result = sink.insert_stream(stream, src_format, resume_tokens)
1602
self.target_repo.autopack()
1605
def insert_stream(self, stream, src_format, resume_tokens):
1606
target = self.target_repo
1607
if target._lock_token:
1608
verb = 'Repository.insert_stream_locked'
1609
extra_args = (target._lock_token or '',)
1610
required_version = (1, 14)
1612
verb = 'Repository.insert_stream'
1614
required_version = (1, 13)
1615
client = target._client
1616
medium = client._medium
1617
if medium._is_remote_before(required_version):
1618
# No possible way this can work.
1619
return self._insert_real(stream, src_format, resume_tokens)
1620
path = target.bzrdir._path_for_remote_call(client)
1621
if not resume_tokens:
1622
# XXX: Ugly but important for correctness, *will* be fixed during
1623
# 1.13 cycle. Pushing a stream that is interrupted results in a
1624
# fallback to the _real_repositories sink *with a partial stream*.
1625
# Thats bad because we insert less data than bzr expected. To avoid
1626
# this we do a trial push to make sure the verb is accessible, and
1627
# do not fallback when actually pushing the stream. A cleanup patch
1628
# is going to look at rewinding/restarting the stream/partial
1630
byte_stream = smart_repo._stream_to_byte_stream([], src_format)
1632
response = client.call_with_body_stream(
1633
(verb, path, '') + extra_args, byte_stream)
1634
except errors.UnknownSmartMethod:
1635
medium._remember_remote_is_before(required_version)
1636
return self._insert_real(stream, src_format, resume_tokens)
1637
byte_stream = smart_repo._stream_to_byte_stream(
1639
resume_tokens = ' '.join(resume_tokens)
1640
response = client.call_with_body_stream(
1641
(verb, path, resume_tokens) + extra_args, byte_stream)
1642
if response[0][0] not in ('ok', 'missing-basis'):
1643
raise errors.UnexpectedSmartServerResponse(response)
1644
if response[0][0] == 'missing-basis':
1645
tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1646
resume_tokens = tokens
1647
return resume_tokens, set(missing_keys)
1649
self.target_repo.refresh_data()
1653
class RemoteStreamSource(repository.StreamSource):
1654
"""Stream data from a remote server."""
1656
def get_stream(self, search):
1657
if (self.from_repository._fallback_repositories and
1658
self.to_format._fetch_order == 'topological'):
1659
return self._real_stream(self.from_repository, search)
1660
return self.missing_parents_chain(search, [self.from_repository] +
1661
self.from_repository._fallback_repositories)
1663
def _real_stream(self, repo, search):
1664
"""Get a stream for search from repo.
1666
This never called RemoteStreamSource.get_stream, and is a heler
1667
for RemoteStreamSource._get_stream to allow getting a stream
1668
reliably whether fallback back because of old servers or trying
1669
to stream from a non-RemoteRepository (which the stacked support
1672
source = repo._get_source(self.to_format)
1673
if isinstance(source, RemoteStreamSource):
1674
return repository.StreamSource.get_stream(source, search)
1675
return source.get_stream(search)
1677
def _get_stream(self, repo, search):
1678
"""Core worker to get a stream from repo for search.
1680
This is used by both get_stream and the stacking support logic. It
1681
deliberately gets a stream for repo which does not need to be
1682
self.from_repository. In the event that repo is not Remote, or
1683
cannot do a smart stream, a fallback is made to the generic
1684
repository._get_stream() interface, via self._real_stream.
1686
In the event of stacking, streams from _get_stream will not
1687
contain all the data for search - this is normal (see get_stream).
1689
:param repo: A repository.
1690
:param search: A search.
1692
# Fallbacks may be non-smart
1693
if not isinstance(repo, RemoteRepository):
1694
return self._real_stream(repo, search)
1695
client = repo._client
1696
medium = client._medium
1697
if medium._is_remote_before((1, 13)):
1698
# streaming was added in 1.13
1699
return self._real_stream(repo, search)
1700
path = repo.bzrdir._path_for_remote_call(client)
1702
search_bytes = repo._serialise_search_result(search)
1703
response = repo._call_with_body_bytes_expecting_body(
1704
'Repository.get_stream',
1705
(path, self.to_format.network_name()), search_bytes)
1706
response_tuple, response_handler = response
1707
except errors.UnknownSmartMethod:
1708
medium._remember_remote_is_before((1,13))
1709
return self._real_stream(repo, search)
1710
if response_tuple[0] != 'ok':
1711
raise errors.UnexpectedSmartServerResponse(response_tuple)
1712
byte_stream = response_handler.read_streamed_body()
1713
src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
1714
if src_format.network_name() != repo._format.network_name():
1715
raise AssertionError(
1716
"Mismatched RemoteRepository and stream src %r, %r" % (
1717
src_format.network_name(), repo._format.network_name()))
1720
def missing_parents_chain(self, search, sources):
1721
"""Chain multiple streams together to handle stacking.
1723
:param search: The overall search to satisfy with streams.
1724
:param sources: A list of Repository objects to query.
1726
self.serialiser = self.to_format._serializer
1727
self.seen_revs = set()
1728
self.referenced_revs = set()
1729
# If there are heads in the search, or the key count is > 0, we are not
1731
while not search.is_empty() and len(sources) > 1:
1732
source = sources.pop(0)
1733
stream = self._get_stream(source, search)
1734
for kind, substream in stream:
1735
if kind != 'revisions':
1736
yield kind, substream
1738
yield kind, self.missing_parents_rev_handler(substream)
1739
search = search.refine(self.seen_revs, self.referenced_revs)
1740
self.seen_revs = set()
1741
self.referenced_revs = set()
1742
if not search.is_empty():
1743
for kind, stream in self._get_stream(sources[0], search):
1746
def missing_parents_rev_handler(self, substream):
1747
for content in substream:
1748
revision_bytes = content.get_bytes_as('fulltext')
1749
revision = self.serialiser.read_revision_from_string(revision_bytes)
1750
self.seen_revs.add(content.key[-1])
1751
self.referenced_revs.update(revision.parent_ids)
1755
class RemoteBranchLockableFiles(LockableFiles):
1756
"""A 'LockableFiles' implementation that talks to a smart server.
1758
This is not a public interface class.
1761
def __init__(self, bzrdir, _client):
1762
self.bzrdir = bzrdir
1763
self._client = _client
1764
self._need_find_modes = True
1765
LockableFiles.__init__(
1766
self, bzrdir.get_branch_transport(None),
1767
'lock', lockdir.LockDir)
1769
def _find_modes(self):
1770
# RemoteBranches don't let the client set the mode of control files.
1771
self._dir_mode = None
1772
self._file_mode = None
1775
class RemoteBranchFormat(branch.BranchFormat):
1777
def __init__(self, network_name=None):
1778
super(RemoteBranchFormat, self).__init__()
1779
self._matchingbzrdir = RemoteBzrDirFormat()
1780
self._matchingbzrdir.set_branch_format(self)
1781
self._custom_format = None
1782
self._network_name = network_name
1784
def __eq__(self, other):
1785
return (isinstance(other, RemoteBranchFormat) and
1786
self.__dict__ == other.__dict__)
1788
def _ensure_real(self):
1789
if self._custom_format is None:
1790
self._custom_format = branch.network_format_registry.get(
1793
def get_format_description(self):
1794
return 'Remote BZR Branch'
1796
def network_name(self):
1797
return self._network_name
1799
def open(self, a_bzrdir, ignore_fallbacks=False):
1800
return a_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
1802
def _vfs_initialize(self, a_bzrdir):
1803
# Initialisation when using a local bzrdir object, or a non-vfs init
1804
# method is not available on the server.
1805
# self._custom_format is always set - the start of initialize ensures
1807
if isinstance(a_bzrdir, RemoteBzrDir):
1808
a_bzrdir._ensure_real()
1809
result = self._custom_format.initialize(a_bzrdir._real_bzrdir)
1811
# We assume the bzrdir is parameterised; it may not be.
1812
result = self._custom_format.initialize(a_bzrdir)
1813
if (isinstance(a_bzrdir, RemoteBzrDir) and
1814
not isinstance(result, RemoteBranch)):
1815
result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result)
1818
def initialize(self, a_bzrdir):
1819
# 1) get the network name to use.
1820
if self._custom_format:
1821
network_name = self._custom_format.network_name()
1823
# Select the current bzrlib default and ask for that.
1824
reference_bzrdir_format = bzrdir.format_registry.get('default')()
1825
reference_format = reference_bzrdir_format.get_branch_format()
1826
self._custom_format = reference_format
1827
network_name = reference_format.network_name()
1828
# Being asked to create on a non RemoteBzrDir:
1829
if not isinstance(a_bzrdir, RemoteBzrDir):
1830
return self._vfs_initialize(a_bzrdir)
1831
medium = a_bzrdir._client._medium
1832
if medium._is_remote_before((1, 13)):
1833
return self._vfs_initialize(a_bzrdir)
1834
# Creating on a remote bzr dir.
1835
# 2) try direct creation via RPC
1836
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
1837
verb = 'BzrDir.create_branch'
1839
response = a_bzrdir._call(verb, path, network_name)
1840
except errors.UnknownSmartMethod:
1841
# Fallback - use vfs methods
1842
medium._remember_remote_is_before((1, 13))
1843
return self._vfs_initialize(a_bzrdir)
1844
if response[0] != 'ok':
1845
raise errors.UnexpectedSmartServerResponse(response)
1846
# Turn the response into a RemoteRepository object.
1847
format = RemoteBranchFormat(network_name=response[1])
1848
repo_format = response_tuple_to_repo_format(response[3:])
1849
if response[2] == '':
1850
repo_bzrdir = a_bzrdir
1852
repo_bzrdir = RemoteBzrDir(
1853
a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
1855
remote_repo = RemoteRepository(repo_bzrdir, repo_format)
1856
remote_branch = RemoteBranch(a_bzrdir, remote_repo,
1857
format=format, setup_stacking=False)
1858
# XXX: We know this is a new branch, so it must have revno 0, revid
1859
# NULL_REVISION. Creating the branch locked would make this be unable
1860
# to be wrong; here its simply very unlikely to be wrong. RBC 20090225
1861
remote_branch._last_revision_info_cache = 0, NULL_REVISION
1862
return remote_branch
1864
def make_tags(self, branch):
1866
return self._custom_format.make_tags(branch)
1868
def supports_tags(self):
1869
# Remote branches might support tags, but we won't know until we
1870
# access the real remote branch.
1872
return self._custom_format.supports_tags()
1874
def supports_stacking(self):
1876
return self._custom_format.supports_stacking()
1879
class RemoteBranch(branch.Branch, _RpcHelper):
1880
"""Branch stored on a server accessed by HPSS RPC.
1882
At the moment most operations are mapped down to simple file operations.
1885
def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
1886
_client=None, format=None, setup_stacking=True):
1887
"""Create a RemoteBranch instance.
1889
:param real_branch: An optional local implementation of the branch
1890
format, usually accessing the data via the VFS.
1891
:param _client: Private parameter for testing.
1892
:param format: A RemoteBranchFormat object, None to create one
1893
automatically. If supplied it should have a network_name already
1895
:param setup_stacking: If True make an RPC call to determine the
1896
stacked (or not) status of the branch. If False assume the branch
1899
# We intentionally don't call the parent class's __init__, because it
1900
# will try to assign to self.tags, which is a property in this subclass.
1901
# And the parent's __init__ doesn't do much anyway.
1902
self._revision_id_to_revno_cache = None
1903
self._partial_revision_id_to_revno_cache = {}
1904
self._revision_history_cache = None
1905
self._last_revision_info_cache = None
1906
self._merge_sorted_revisions_cache = None
1907
self.bzrdir = remote_bzrdir
1908
if _client is not None:
1909
self._client = _client
1911
self._client = remote_bzrdir._client
1912
self.repository = remote_repository
1913
if real_branch is not None:
1914
self._real_branch = real_branch
1915
# Give the remote repository the matching real repo.
1916
real_repo = self._real_branch.repository
1917
if isinstance(real_repo, RemoteRepository):
1918
real_repo._ensure_real()
1919
real_repo = real_repo._real_repository
1920
self.repository._set_real_repository(real_repo)
1921
# Give the branch the remote repository to let fast-pathing happen.
1922
self._real_branch.repository = self.repository
1924
self._real_branch = None
1925
# Fill out expected attributes of branch for bzrlib API users.
1926
self.base = self.bzrdir.root_transport.base
1927
self._control_files = None
1928
self._lock_mode = None
1929
self._lock_token = None
1930
self._repo_lock_token = None
1931
self._lock_count = 0
1932
self._leave_lock = False
1933
# Setup a format: note that we cannot call _ensure_real until all the
1934
# attributes above are set: This code cannot be moved higher up in this
1937
self._format = RemoteBranchFormat()
1938
if real_branch is not None:
1939
self._format._network_name = \
1940
self._real_branch._format.network_name()
1942
self._format = format
1943
if not self._format._network_name:
1944
# Did not get from open_branchV2 - old server.
1946
self._format._network_name = \
1947
self._real_branch._format.network_name()
1948
self.tags = self._format.make_tags(self)
1949
# The base class init is not called, so we duplicate this:
1950
hooks = branch.Branch.hooks['open']
1954
self._setup_stacking()
1956
def _setup_stacking(self):
1957
# configure stacking into the remote repository, by reading it from
1960
fallback_url = self.get_stacked_on_url()
1961
except (errors.NotStacked, errors.UnstackableBranchFormat,
1962
errors.UnstackableRepositoryFormat), e:
1964
self._activate_fallback_location(fallback_url, None)
1966
def _get_config(self):
1967
return RemoteBranchConfig(self)
1969
def _get_real_transport(self):
1970
# if we try vfs access, return the real branch's vfs transport
1972
return self._real_branch._transport
1974
_transport = property(_get_real_transport)
1977
return "%s(%s)" % (self.__class__.__name__, self.base)
1981
def _ensure_real(self):
1982
"""Ensure that there is a _real_branch set.
1984
Used before calls to self._real_branch.
1986
if self._real_branch is None:
1987
if not vfs.vfs_enabled():
1988
raise AssertionError('smart server vfs must be enabled '
1989
'to use vfs implementation')
1990
self.bzrdir._ensure_real()
1991
self._real_branch = self.bzrdir._real_bzrdir.open_branch()
1992
if self.repository._real_repository is None:
1993
# Give the remote repository the matching real repo.
1994
real_repo = self._real_branch.repository
1995
if isinstance(real_repo, RemoteRepository):
1996
real_repo._ensure_real()
1997
real_repo = real_repo._real_repository
1998
self.repository._set_real_repository(real_repo)
1999
# Give the real branch the remote repository to let fast-pathing
2001
self._real_branch.repository = self.repository
2002
if self._lock_mode == 'r':
2003
self._real_branch.lock_read()
2004
elif self._lock_mode == 'w':
2005
self._real_branch.lock_write(token=self._lock_token)
2007
def _translate_error(self, err, **context):
2008
self.repository._translate_error(err, branch=self, **context)
2010
def _clear_cached_state(self):
2011
super(RemoteBranch, self)._clear_cached_state()
2012
if self._real_branch is not None:
2013
self._real_branch._clear_cached_state()
2015
def _clear_cached_state_of_remote_branch_only(self):
2016
"""Like _clear_cached_state, but doesn't clear the cache of
2019
This is useful when falling back to calling a method of
2020
self._real_branch that changes state. In that case the underlying
2021
branch changes, so we need to invalidate this RemoteBranch's cache of
2022
it. However, there's no need to invalidate the _real_branch's cache
2023
too, in fact doing so might harm performance.
2025
super(RemoteBranch, self)._clear_cached_state()
2028
def control_files(self):
2029
# Defer actually creating RemoteBranchLockableFiles until its needed,
2030
# because it triggers an _ensure_real that we otherwise might not need.
2031
if self._control_files is None:
2032
self._control_files = RemoteBranchLockableFiles(
2033
self.bzrdir, self._client)
2034
return self._control_files
2036
def _get_checkout_format(self):
2038
return self._real_branch._get_checkout_format()
2040
def get_physical_lock_status(self):
2041
"""See Branch.get_physical_lock_status()."""
2042
# should be an API call to the server, as branches must be lockable.
2044
return self._real_branch.get_physical_lock_status()
2046
def get_stacked_on_url(self):
2047
"""Get the URL this branch is stacked against.
2049
:raises NotStacked: If the branch is not stacked.
2050
:raises UnstackableBranchFormat: If the branch does not support
2052
:raises UnstackableRepositoryFormat: If the repository does not support
2056
# there may not be a repository yet, so we can't use
2057
# self._translate_error, so we can't use self._call either.
2058
response = self._client.call('Branch.get_stacked_on_url',
2059
self._remote_path())
2060
except errors.ErrorFromSmartServer, err:
2061
# there may not be a repository yet, so we can't call through
2062
# its _translate_error
2063
_translate_error(err, branch=self)
2064
except errors.UnknownSmartMethod, err:
2066
return self._real_branch.get_stacked_on_url()
2067
if response[0] != 'ok':
2068
raise errors.UnexpectedSmartServerResponse(response)
2071
def _vfs_get_tags_bytes(self):
2073
return self._real_branch._get_tags_bytes()
2075
def _get_tags_bytes(self):
2076
medium = self._client._medium
2077
if medium._is_remote_before((1, 13)):
2078
return self._vfs_get_tags_bytes()
2080
response = self._call('Branch.get_tags_bytes', self._remote_path())
2081
except errors.UnknownSmartMethod:
2082
medium._remember_remote_is_before((1, 13))
2083
return self._vfs_get_tags_bytes()
2086
def lock_read(self):
2087
self.repository.lock_read()
2088
if not self._lock_mode:
2089
self._lock_mode = 'r'
2090
self._lock_count = 1
2091
if self._real_branch is not None:
2092
self._real_branch.lock_read()
2094
self._lock_count += 1
2096
def _remote_lock_write(self, token):
2098
branch_token = repo_token = ''
2100
branch_token = token
2101
repo_token = self.repository.lock_write()
2102
self.repository.unlock()
2103
err_context = {'token': token}
2104
response = self._call(
2105
'Branch.lock_write', self._remote_path(), branch_token,
2106
repo_token or '', **err_context)
2107
if response[0] != 'ok':
2108
raise errors.UnexpectedSmartServerResponse(response)
2109
ok, branch_token, repo_token = response
2110
return branch_token, repo_token
2112
def lock_write(self, token=None):
2113
if not self._lock_mode:
2114
# Lock the branch and repo in one remote call.
2115
remote_tokens = self._remote_lock_write(token)
2116
self._lock_token, self._repo_lock_token = remote_tokens
2117
if not self._lock_token:
2118
raise SmartProtocolError('Remote server did not return a token!')
2119
# Tell the self.repository object that it is locked.
2120
self.repository.lock_write(
2121
self._repo_lock_token, _skip_rpc=True)
2123
if self._real_branch is not None:
2124
self._real_branch.lock_write(token=self._lock_token)
2125
if token is not None:
2126
self._leave_lock = True
2128
self._leave_lock = False
2129
self._lock_mode = 'w'
2130
self._lock_count = 1
2131
elif self._lock_mode == 'r':
2132
raise errors.ReadOnlyTransaction
2134
if token is not None:
2135
# A token was given to lock_write, and we're relocking, so
2136
# check that the given token actually matches the one we
2138
if token != self._lock_token:
2139
raise errors.TokenMismatch(token, self._lock_token)
2140
self._lock_count += 1
2141
# Re-lock the repository too.
2142
self.repository.lock_write(self._repo_lock_token)
2143
return self._lock_token or None
2145
def _set_tags_bytes(self, bytes):
2147
return self._real_branch._set_tags_bytes(bytes)
2149
def _unlock(self, branch_token, repo_token):
2150
err_context = {'token': str((branch_token, repo_token))}
2151
response = self._call(
2152
'Branch.unlock', self._remote_path(), branch_token,
2153
repo_token or '', **err_context)
2154
if response == ('ok',):
2156
raise errors.UnexpectedSmartServerResponse(response)
2160
self._lock_count -= 1
2161
if not self._lock_count:
2162
self._clear_cached_state()
2163
mode = self._lock_mode
2164
self._lock_mode = None
2165
if self._real_branch is not None:
2166
if (not self._leave_lock and mode == 'w' and
2167
self._repo_lock_token):
2168
# If this RemoteBranch will remove the physical lock
2169
# for the repository, make sure the _real_branch
2170
# doesn't do it first. (Because the _real_branch's
2171
# repository is set to be the RemoteRepository.)
2172
self._real_branch.repository.leave_lock_in_place()
2173
self._real_branch.unlock()
2175
# Only write-locked branched need to make a remote method
2176
# call to perform the unlock.
2178
if not self._lock_token:
2179
raise AssertionError('Locked, but no token!')
2180
branch_token = self._lock_token
2181
repo_token = self._repo_lock_token
2182
self._lock_token = None
2183
self._repo_lock_token = None
2184
if not self._leave_lock:
2185
self._unlock(branch_token, repo_token)
2187
self.repository.unlock()
2189
def break_lock(self):
2191
return self._real_branch.break_lock()
2193
def leave_lock_in_place(self):
2194
if not self._lock_token:
2195
raise NotImplementedError(self.leave_lock_in_place)
2196
self._leave_lock = True
2198
def dont_leave_lock_in_place(self):
2199
if not self._lock_token:
2200
raise NotImplementedError(self.dont_leave_lock_in_place)
2201
self._leave_lock = False
2203
def _last_revision_info(self):
2204
response = self._call('Branch.last_revision_info', self._remote_path())
2205
if response[0] != 'ok':
2206
raise SmartProtocolError('unexpected response code %s' % (response,))
2207
revno = int(response[1])
2208
last_revision = response[2]
2209
return (revno, last_revision)
2211
def _gen_revision_history(self):
2212
"""See Branch._gen_revision_history()."""
2213
response_tuple, response_handler = self._call_expecting_body(
2214
'Branch.revision_history', self._remote_path())
2215
if response_tuple[0] != 'ok':
2216
raise errors.UnexpectedSmartServerResponse(response_tuple)
2217
result = response_handler.read_body_bytes().split('\x00')
2222
def _remote_path(self):
2223
return self.bzrdir._path_for_remote_call(self._client)
2225
def _set_last_revision_descendant(self, revision_id, other_branch,
2226
allow_diverged=False, allow_overwrite_descendant=False):
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
old_revno, old_revid = self.last_revision_info()
2234
history = self._lefthand_history(revision_id)
2235
self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2236
err_context = {'other_branch': other_branch}
2237
response = self._call('Branch.set_last_revision_ex',
2238
self._remote_path(), self._lock_token, self._repo_lock_token,
2239
revision_id, int(allow_diverged), int(allow_overwrite_descendant),
2241
self._clear_cached_state()
2242
if len(response) != 3 and response[0] != 'ok':
2243
raise errors.UnexpectedSmartServerResponse(response)
2244
new_revno, new_revision_id = response[1:]
2245
self._last_revision_info_cache = new_revno, new_revision_id
2246
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2247
if self._real_branch is not None:
2248
cache = new_revno, new_revision_id
2249
self._real_branch._last_revision_info_cache = cache
2251
def _set_last_revision(self, revision_id):
2252
old_revno, old_revid = self.last_revision_info()
2253
# This performs additional work to meet the hook contract; while its
2254
# undesirable, we have to synthesise the revno to call the hook, and
2255
# not calling the hook is worse as it means changes can't be prevented.
2256
# Having calculated this though, we can't just call into
2257
# set_last_revision_info as a simple call, because there is a set_rh
2258
# hook that some folk may still be using.
2259
history = self._lefthand_history(revision_id)
2260
self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2261
self._clear_cached_state()
2262
response = self._call('Branch.set_last_revision',
2263
self._remote_path(), self._lock_token, self._repo_lock_token,
2265
if response != ('ok',):
2266
raise errors.UnexpectedSmartServerResponse(response)
2267
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2270
def set_revision_history(self, rev_history):
2271
# Send just the tip revision of the history; the server will generate
2272
# the full history from that. If the revision doesn't exist in this
2273
# branch, NoSuchRevision will be raised.
2274
if rev_history == []:
2277
rev_id = rev_history[-1]
2278
self._set_last_revision(rev_id)
2279
for hook in branch.Branch.hooks['set_rh']:
2280
hook(self, rev_history)
2281
self._cache_revision_history(rev_history)
2283
def _get_parent_location(self):
2284
medium = self._client._medium
2285
if medium._is_remote_before((1, 13)):
2286
return self._vfs_get_parent_location()
2288
response = self._call('Branch.get_parent', self._remote_path())
2289
except errors.UnknownSmartMethod:
2290
medium._remember_remote_is_before((1, 13))
2291
return self._vfs_get_parent_location()
2292
if len(response) != 1:
2293
raise errors.UnexpectedSmartServerResponse(response)
2294
parent_location = response[0]
2295
if parent_location == '':
2297
return parent_location
2299
def _vfs_get_parent_location(self):
2301
return self._real_branch._get_parent_location()
2303
def _set_parent_location(self, url):
2304
medium = self._client._medium
2305
if medium._is_remote_before((1, 15)):
2306
return self._vfs_set_parent_location(url)
2308
call_url = url or ''
2309
if type(call_url) is not str:
2310
raise AssertionError('url must be a str or None (%s)' % url)
2311
response = self._call('Branch.set_parent_location',
2312
self._remote_path(), self._lock_token, self._repo_lock_token,
2314
except errors.UnknownSmartMethod:
2315
medium._remember_remote_is_before((1, 15))
2316
return self._vfs_set_parent_location(url)
2318
raise errors.UnexpectedSmartServerResponse(response)
2320
def _vfs_set_parent_location(self, url):
2322
return self._real_branch._set_parent_location(url)
2325
def pull(self, source, overwrite=False, stop_revision=None,
2327
self._clear_cached_state_of_remote_branch_only()
2329
return self._real_branch.pull(
2330
source, overwrite=overwrite, stop_revision=stop_revision,
2331
_override_hook_target=self, **kwargs)
2334
def push(self, target, overwrite=False, stop_revision=None):
2336
return self._real_branch.push(
2337
target, overwrite=overwrite, stop_revision=stop_revision,
2338
_override_hook_source_branch=self)
2340
def is_locked(self):
2341
return self._lock_count >= 1
2344
def revision_id_to_revno(self, revision_id):
2346
return self._real_branch.revision_id_to_revno(revision_id)
2349
def set_last_revision_info(self, revno, revision_id):
2350
# XXX: These should be returned by the set_last_revision_info verb
2351
old_revno, old_revid = self.last_revision_info()
2352
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2353
revision_id = ensure_null(revision_id)
2355
response = self._call('Branch.set_last_revision_info',
2356
self._remote_path(), self._lock_token, self._repo_lock_token,
2357
str(revno), revision_id)
2358
except errors.UnknownSmartMethod:
2360
self._clear_cached_state_of_remote_branch_only()
2361
self._real_branch.set_last_revision_info(revno, revision_id)
2362
self._last_revision_info_cache = revno, revision_id
2364
if response == ('ok',):
2365
self._clear_cached_state()
2366
self._last_revision_info_cache = revno, revision_id
2367
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2368
# Update the _real_branch's cache too.
2369
if self._real_branch is not None:
2370
cache = self._last_revision_info_cache
2371
self._real_branch._last_revision_info_cache = cache
2373
raise errors.UnexpectedSmartServerResponse(response)
2376
def generate_revision_history(self, revision_id, last_rev=None,
2378
medium = self._client._medium
2379
if not medium._is_remote_before((1, 6)):
2380
# Use a smart method for 1.6 and above servers
2382
self._set_last_revision_descendant(revision_id, other_branch,
2383
allow_diverged=True, allow_overwrite_descendant=True)
2385
except errors.UnknownSmartMethod:
2386
medium._remember_remote_is_before((1, 6))
2387
self._clear_cached_state_of_remote_branch_only()
2388
self.set_revision_history(self._lefthand_history(revision_id,
2389
last_rev=last_rev,other_branch=other_branch))
2391
def set_push_location(self, location):
2393
return self._real_branch.set_push_location(location)
2396
class RemoteConfig(object):
2397
"""A Config that reads and writes from smart verbs.
2399
It is a low-level object that considers config data to be name/value pairs
2400
that may be associated with a section. Assigning meaning to the these
2401
values is done at higher levels like bzrlib.config.TreeConfig.
2404
def get_option(self, name, section=None, default=None):
2405
"""Return the value associated with a named option.
2407
:param name: The name of the value
2408
:param section: The section the option is in (if any)
2409
:param default: The value to return if the value is not set
2410
:return: The value or default value
2413
configobj = self._get_configobj()
2415
section_obj = configobj
2418
section_obj = configobj[section]
2421
return section_obj.get(name, default)
2422
except errors.UnknownSmartMethod:
2423
return self._vfs_get_option(name, section, default)
2425
def _response_to_configobj(self, response):
2426
if len(response[0]) and response[0][0] != 'ok':
2427
raise errors.UnexpectedSmartServerResponse(response)
2428
lines = response[1].read_body_bytes().splitlines()
2429
return config.ConfigObj(lines, encoding='utf-8')
2432
class RemoteBranchConfig(RemoteConfig):
2433
"""A RemoteConfig for Branches."""
2435
def __init__(self, branch):
2436
self._branch = branch
2438
def _get_configobj(self):
2439
path = self._branch._remote_path()
2440
response = self._branch._client.call_expecting_body(
2441
'Branch.get_config_file', path)
2442
return self._response_to_configobj(response)
2444
def set_option(self, value, name, section=None):
2445
"""Set the value associated with a named option.
2447
:param value: The value to set
2448
:param name: The name of the value to set
2449
:param section: The section the option is in (if any)
2451
medium = self._branch._client._medium
2452
if medium._is_remote_before((1, 14)):
2453
return self._vfs_set_option(value, name, section)
2455
path = self._branch._remote_path()
2456
response = self._branch._client.call('Branch.set_config_option',
2457
path, self._branch._lock_token, self._branch._repo_lock_token,
2458
value.encode('utf8'), name, section or '')
2459
except errors.UnknownSmartMethod:
2460
medium._remember_remote_is_before((1, 14))
2461
return self._vfs_set_option(value, name, section)
2463
raise errors.UnexpectedSmartServerResponse(response)
2465
def _real_object(self):
2466
self._branch._ensure_real()
2467
return self._branch._real_branch
2469
def _vfs_set_option(self, value, name, section=None):
2470
return self._real_object()._get_config().set_option(
2471
value, name, section)
2474
class RemoteBzrDirConfig(RemoteConfig):
2475
"""A RemoteConfig for BzrDirs."""
2477
def __init__(self, bzrdir):
2478
self._bzrdir = bzrdir
2480
def _get_configobj(self):
2481
medium = self._bzrdir._client._medium
2482
verb = 'BzrDir.get_config_file'
2483
if medium._is_remote_before((1, 15)):
2484
raise errors.UnknownSmartMethod(verb)
2485
path = self._bzrdir._path_for_remote_call(self._bzrdir._client)
2486
response = self._bzrdir._call_expecting_body(
2488
return self._response_to_configobj(response)
2490
def _vfs_get_option(self, name, section, default):
2491
return self._real_object()._get_config().get_option(
2492
name, section, default)
2494
def set_option(self, value, name, section=None):
2495
"""Set the value associated with a named option.
2497
:param value: The value to set
2498
:param name: The name of the value to set
2499
:param section: The section the option is in (if any)
2501
return self._real_object()._get_config().set_option(
2502
value, name, section)
2504
def _real_object(self):
2505
self._bzrdir._ensure_real()
2506
return self._bzrdir._real_bzrdir
2510
def _extract_tar(tar, to_dir):
2511
"""Extract all the contents of a tarfile object.
2513
A replacement for extractall, which is not present in python2.4
2516
tar.extract(tarinfo, to_dir)
2519
def _translate_error(err, **context):
2520
"""Translate an ErrorFromSmartServer into a more useful error.
2522
Possible context keys:
2530
If the error from the server doesn't match a known pattern, then
2531
UnknownErrorFromSmartServer is raised.
2535
return context[name]
2536
except KeyError, key_err:
2537
mutter('Missing key %r in context %r', key_err.args[0], context)
2540
"""Get the path from the context if present, otherwise use first error
2544
return context['path']
2545
except KeyError, key_err:
2547
return err.error_args[0]
2548
except IndexError, idx_err:
2550
'Missing key %r in context %r', key_err.args[0], context)
2553
if err.error_verb == 'NoSuchRevision':
2554
raise NoSuchRevision(find('branch'), err.error_args[0])
2555
elif err.error_verb == 'nosuchrevision':
2556
raise NoSuchRevision(find('repository'), err.error_args[0])
2557
elif err.error_tuple == ('nobranch',):
2558
raise errors.NotBranchError(path=find('bzrdir').root_transport.base)
2559
elif err.error_verb == 'norepository':
2560
raise errors.NoRepositoryPresent(find('bzrdir'))
2561
elif err.error_verb == 'LockContention':
2562
raise errors.LockContention('(remote lock)')
2563
elif err.error_verb == 'UnlockableTransport':
2564
raise errors.UnlockableTransport(find('bzrdir').root_transport)
2565
elif err.error_verb == 'LockFailed':
2566
raise errors.LockFailed(err.error_args[0], err.error_args[1])
2567
elif err.error_verb == 'TokenMismatch':
2568
raise errors.TokenMismatch(find('token'), '(remote token)')
2569
elif err.error_verb == 'Diverged':
2570
raise errors.DivergedBranches(find('branch'), find('other_branch'))
2571
elif err.error_verb == 'TipChangeRejected':
2572
raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
2573
elif err.error_verb == 'UnstackableBranchFormat':
2574
raise errors.UnstackableBranchFormat(*err.error_args)
2575
elif err.error_verb == 'UnstackableRepositoryFormat':
2576
raise errors.UnstackableRepositoryFormat(*err.error_args)
2577
elif err.error_verb == 'NotStacked':
2578
raise errors.NotStacked(branch=find('branch'))
2579
elif err.error_verb == 'PermissionDenied':
2581
if len(err.error_args) >= 2:
2582
extra = err.error_args[1]
2585
raise errors.PermissionDenied(path, extra=extra)
2586
elif err.error_verb == 'ReadError':
2588
raise errors.ReadError(path)
2589
elif err.error_verb == 'NoSuchFile':
2591
raise errors.NoSuchFile(path)
2592
elif err.error_verb == 'FileExists':
2593
raise errors.FileExists(err.error_args[0])
2594
elif err.error_verb == 'DirectoryNotEmpty':
2595
raise errors.DirectoryNotEmpty(err.error_args[0])
2596
elif err.error_verb == 'ShortReadvError':
2597
args = err.error_args
2598
raise errors.ShortReadvError(
2599
args[0], int(args[1]), int(args[2]), int(args[3]))
2600
elif err.error_verb in ('UnicodeEncodeError', 'UnicodeDecodeError'):
2601
encoding = str(err.error_args[0]) # encoding must always be a string
2602
val = err.error_args[1]
2603
start = int(err.error_args[2])
2604
end = int(err.error_args[3])
2605
reason = str(err.error_args[4]) # reason must always be a string
2606
if val.startswith('u:'):
2607
val = val[2:].decode('utf-8')
2608
elif val.startswith('s:'):
2609
val = val[2:].decode('base64')
2610
if err.error_verb == 'UnicodeDecodeError':
2611
raise UnicodeDecodeError(encoding, val, start, end, reason)
2612
elif err.error_verb == 'UnicodeEncodeError':
2613
raise UnicodeEncodeError(encoding, val, start, end, reason)
2614
elif err.error_verb == 'ReadOnlyError':
2615
raise errors.TransportNotPossible('readonly transport')
2616
raise errors.UnknownErrorFromSmartServer(err)
added
removed
bzrlib/remote.py
