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()
494
elif self._network_name:
495
network_name = self._network_name
497
# Select the current bzrlib default and ask for that.
498
reference_bzrdir_format = bzrdir.format_registry.get('default')()
499
reference_format = reference_bzrdir_format.repository_format
500
network_name = reference_format.network_name()
501
# 2) try direct creation via RPC
502
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
503
verb = 'BzrDir.create_repository'
509
response = a_bzrdir._call(verb, path, network_name, shared_str)
510
except errors.UnknownSmartMethod:
511
# Fallback - use vfs methods
512
medium._remember_remote_is_before((1, 13))
513
return self._vfs_initialize(a_bzrdir, shared)
515
# Turn the response into a RemoteRepository object.
516
format = response_tuple_to_repo_format(response[1:])
517
# Used to support creating a real format instance when needed.
518
format._creating_bzrdir = a_bzrdir
519
remote_repo = RemoteRepository(a_bzrdir, format)
520
format._creating_repo = remote_repo
523
def open(self, a_bzrdir):
524
if not isinstance(a_bzrdir, RemoteBzrDir):
525
raise AssertionError('%r is not a RemoteBzrDir' % (a_bzrdir,))
526
return a_bzrdir.open_repository()
528
def _ensure_real(self):
529
if self._custom_format is None:
530
self._custom_format = repository.network_format_registry.get(
534
def _fetch_order(self):
536
return self._custom_format._fetch_order
539
def _fetch_uses_deltas(self):
541
return self._custom_format._fetch_uses_deltas
544
def _fetch_reconcile(self):
546
return self._custom_format._fetch_reconcile
548
def get_format_description(self):
549
return 'bzr remote repository'
551
def __eq__(self, other):
552
return self.__class__ is other.__class__
554
def check_conversion_target(self, target_format):
555
if self.rich_root_data and not target_format.rich_root_data:
556
raise errors.BadConversionTarget(
557
'Does not support rich root data.', target_format)
558
if (self.supports_tree_reference and
559
not getattr(target_format, 'supports_tree_reference', False)):
560
raise errors.BadConversionTarget(
561
'Does not support nested trees', target_format)
563
def network_name(self):
564
if self._network_name:
565
return self._network_name
566
self._creating_repo._ensure_real()
567
return self._creating_repo._real_repository._format.network_name()
570
def _serializer(self):
572
return self._custom_format._serializer
575
class RemoteRepository(_RpcHelper):
576
"""Repository accessed over rpc.
578
For the moment most operations are performed using local transport-backed
582
def __init__(self, remote_bzrdir, format, real_repository=None, _client=None):
583
"""Create a RemoteRepository instance.
585
:param remote_bzrdir: The bzrdir hosting this repository.
586
:param format: The RemoteFormat object to use.
587
:param real_repository: If not None, a local implementation of the
588
repository logic for the repository, usually accessing the data
590
:param _client: Private testing parameter - override the smart client
591
to be used by the repository.
594
self._real_repository = real_repository
596
self._real_repository = None
597
self.bzrdir = remote_bzrdir
599
self._client = remote_bzrdir._client
601
self._client = _client
602
self._format = format
603
self._lock_mode = None
604
self._lock_token = None
606
self._leave_lock = False
607
self._unstacked_provider = graph.CachingParentsProvider(
608
get_parent_map=self._get_parent_map_rpc)
609
self._unstacked_provider.disable_cache()
611
# These depend on the actual remote format, so force them off for
612
# maximum compatibility. XXX: In future these should depend on the
613
# remote repository instance, but this is irrelevant until we perform
614
# reconcile via an RPC call.
615
self._reconcile_does_inventory_gc = False
616
self._reconcile_fixes_text_parents = False
617
self._reconcile_backsup_inventory = False
618
self.base = self.bzrdir.transport.base
619
# Additional places to query for data.
620
self._fallback_repositories = []
623
return "%s(%s)" % (self.__class__.__name__, self.base)
627
def abort_write_group(self, suppress_errors=False):
628
"""Complete a write group on the decorated repository.
630
Smart methods perform operations in a single step so this API
631
is not really applicable except as a compatibility thunk
632
for older plugins that don't use e.g. the CommitBuilder
635
:param suppress_errors: see Repository.abort_write_group.
638
return self._real_repository.abort_write_group(
639
suppress_errors=suppress_errors)
643
"""Decorate the real repository for now.
645
In the long term a full blown network facility is needed to avoid
646
creating a real repository object locally.
649
return self._real_repository.chk_bytes
651
def commit_write_group(self):
652
"""Complete a write group on the decorated repository.
654
Smart methods perform operations in a single step so this API
655
is not really applicable except as a compatibility thunk
656
for older plugins that don't use e.g. the CommitBuilder
660
return self._real_repository.commit_write_group()
662
def resume_write_group(self, tokens):
664
return self._real_repository.resume_write_group(tokens)
666
def suspend_write_group(self):
668
return self._real_repository.suspend_write_group()
670
def _ensure_real(self):
671
"""Ensure that there is a _real_repository set.
673
Used before calls to self._real_repository.
675
Note that _ensure_real causes many roundtrips to the server which are
676
not desirable, and prevents the use of smart one-roundtrip RPC's to
677
perform complex operations (such as accessing parent data, streaming
678
revisions etc). Adding calls to _ensure_real should only be done when
679
bringing up new functionality, adding fallbacks for smart methods that
680
require a fallback path, and never to replace an existing smart method
681
invocation. If in doubt chat to the bzr network team.
683
if self._real_repository is None:
684
self.bzrdir._ensure_real()
685
self._set_real_repository(
686
self.bzrdir._real_bzrdir.open_repository())
688
def _translate_error(self, err, **context):
689
self.bzrdir._translate_error(err, repository=self, **context)
691
def find_text_key_references(self):
692
"""Find the text key references within the repository.
694
:return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
695
revision_ids. Each altered file-ids has the exact revision_ids that
696
altered it listed explicitly.
697
:return: A dictionary mapping text keys ((fileid, revision_id) tuples)
698
to whether they were referred to by the inventory of the
699
revision_id that they contain. The inventory texts from all present
700
revision ids are assessed to generate this report.
703
return self._real_repository.find_text_key_references()
705
def _generate_text_key_index(self):
706
"""Generate a new text key index for the repository.
708
This is an expensive function that will take considerable time to run.
710
:return: A dict mapping (file_id, revision_id) tuples to a list of
711
parents, also (file_id, revision_id) tuples.
714
return self._real_repository._generate_text_key_index()
716
def _get_revision_graph(self, revision_id):
717
"""Private method for using with old (< 1.2) servers to fallback."""
718
if revision_id is None:
720
elif revision.is_null(revision_id):
723
path = self.bzrdir._path_for_remote_call(self._client)
724
response = self._call_expecting_body(
725
'Repository.get_revision_graph', path, revision_id)
726
response_tuple, response_handler = response
727
if response_tuple[0] != 'ok':
728
raise errors.UnexpectedSmartServerResponse(response_tuple)
729
coded = response_handler.read_body_bytes()
731
# no revisions in this repository!
733
lines = coded.split('\n')
736
d = tuple(line.split())
737
revision_graph[d[0]] = d[1:]
739
return revision_graph
742
"""See Repository._get_sink()."""
743
return RemoteStreamSink(self)
745
def _get_source(self, to_format):
746
"""Return a source for streaming from this repository."""
747
return RemoteStreamSource(self, to_format)
749
def has_revision(self, revision_id):
750
"""See Repository.has_revision()."""
751
if revision_id == NULL_REVISION:
752
# The null revision is always present.
754
path = self.bzrdir._path_for_remote_call(self._client)
755
response = self._call('Repository.has_revision', path, revision_id)
756
if response[0] not in ('yes', 'no'):
757
raise errors.UnexpectedSmartServerResponse(response)
758
if response[0] == 'yes':
760
for fallback_repo in self._fallback_repositories:
761
if fallback_repo.has_revision(revision_id):
765
def has_revisions(self, revision_ids):
766
"""See Repository.has_revisions()."""
767
# FIXME: This does many roundtrips, particularly when there are
768
# fallback repositories. -- mbp 20080905
770
for revision_id in revision_ids:
771
if self.has_revision(revision_id):
772
result.add(revision_id)
775
def has_same_location(self, other):
776
return (self.__class__ is other.__class__ and
777
self.bzrdir.transport.base == other.bzrdir.transport.base)
779
def get_graph(self, other_repository=None):
780
"""Return the graph for this repository format"""
781
parents_provider = self._make_parents_provider(other_repository)
782
return graph.Graph(parents_provider)
784
def gather_stats(self, revid=None, committers=None):
785
"""See Repository.gather_stats()."""
786
path = self.bzrdir._path_for_remote_call(self._client)
787
# revid can be None to indicate no revisions, not just NULL_REVISION
788
if revid is None or revision.is_null(revid):
792
if committers is None or not committers:
793
fmt_committers = 'no'
795
fmt_committers = 'yes'
796
response_tuple, response_handler = self._call_expecting_body(
797
'Repository.gather_stats', path, fmt_revid, fmt_committers)
798
if response_tuple[0] != 'ok':
799
raise errors.UnexpectedSmartServerResponse(response_tuple)
801
body = response_handler.read_body_bytes()
803
for line in body.split('\n'):
806
key, val_text = line.split(':')
807
if key in ('revisions', 'size', 'committers'):
808
result[key] = int(val_text)
809
elif key in ('firstrev', 'latestrev'):
810
values = val_text.split(' ')[1:]
811
result[key] = (float(values[0]), long(values[1]))
815
def find_branches(self, using=False):
816
"""See Repository.find_branches()."""
817
# should be an API call to the server.
819
return self._real_repository.find_branches(using=using)
821
def get_physical_lock_status(self):
822
"""See Repository.get_physical_lock_status()."""
823
# should be an API call to the server.
825
return self._real_repository.get_physical_lock_status()
827
def is_in_write_group(self):
828
"""Return True if there is an open write group.
830
write groups are only applicable locally for the smart server..
832
if self._real_repository:
833
return self._real_repository.is_in_write_group()
836
return self._lock_count >= 1
839
"""See Repository.is_shared()."""
840
path = self.bzrdir._path_for_remote_call(self._client)
841
response = self._call('Repository.is_shared', path)
842
if response[0] not in ('yes', 'no'):
843
raise SmartProtocolError('unexpected response code %s' % (response,))
844
return response[0] == 'yes'
846
def is_write_locked(self):
847
return self._lock_mode == 'w'
850
# wrong eventually - want a local lock cache context
851
if not self._lock_mode:
852
self._lock_mode = 'r'
854
self._unstacked_provider.enable_cache(cache_misses=True)
855
if self._real_repository is not None:
856
self._real_repository.lock_read()
858
self._lock_count += 1
859
for repo in self._fallback_repositories:
862
def _remote_lock_write(self, token):
863
path = self.bzrdir._path_for_remote_call(self._client)
866
err_context = {'token': token}
867
response = self._call('Repository.lock_write', path, token,
869
if response[0] == 'ok':
873
raise errors.UnexpectedSmartServerResponse(response)
875
def lock_write(self, token=None, _skip_rpc=False):
876
if not self._lock_mode:
878
if self._lock_token is not None:
879
if token != self._lock_token:
880
raise errors.TokenMismatch(token, self._lock_token)
881
self._lock_token = token
883
self._lock_token = self._remote_lock_write(token)
884
# if self._lock_token is None, then this is something like packs or
885
# svn where we don't get to lock the repo, or a weave style repository
886
# where we cannot lock it over the wire and attempts to do so will
888
if self._real_repository is not None:
889
self._real_repository.lock_write(token=self._lock_token)
890
if token is not None:
891
self._leave_lock = True
893
self._leave_lock = False
894
self._lock_mode = 'w'
896
self._unstacked_provider.enable_cache(cache_misses=False)
897
elif self._lock_mode == 'r':
898
raise errors.ReadOnlyError(self)
900
self._lock_count += 1
901
for repo in self._fallback_repositories:
902
# Writes don't affect fallback repos
904
return self._lock_token or None
906
def leave_lock_in_place(self):
907
if not self._lock_token:
908
raise NotImplementedError(self.leave_lock_in_place)
909
self._leave_lock = True
911
def dont_leave_lock_in_place(self):
912
if not self._lock_token:
913
raise NotImplementedError(self.dont_leave_lock_in_place)
914
self._leave_lock = False
916
def _set_real_repository(self, repository):
917
"""Set the _real_repository for this repository.
919
:param repository: The repository to fallback to for non-hpss
920
implemented operations.
922
if self._real_repository is not None:
923
# Replacing an already set real repository.
924
# We cannot do this [currently] if the repository is locked -
925
# synchronised state might be lost.
927
raise AssertionError('_real_repository is already set')
928
if isinstance(repository, RemoteRepository):
929
raise AssertionError()
930
self._real_repository = repository
931
# three code paths happen here:
932
# 1) old servers, RemoteBranch.open() calls _ensure_real before setting
933
# up stacking. In this case self._fallback_repositories is [], and the
934
# real repo is already setup. Preserve the real repo and
935
# RemoteRepository.add_fallback_repository will avoid adding
937
# 2) new servers, RemoteBranch.open() sets up stacking, and when
938
# ensure_real is triggered from a branch, the real repository to
939
# set already has a matching list with separate instances, but
940
# as they are also RemoteRepositories we don't worry about making the
941
# lists be identical.
942
# 3) new servers, RemoteRepository.ensure_real is triggered before
943
# RemoteBranch.ensure real, in this case we get a repo with no fallbacks
944
# and need to populate it.
945
if (self._fallback_repositories and
946
len(self._real_repository._fallback_repositories) !=
947
len(self._fallback_repositories)):
948
if len(self._real_repository._fallback_repositories):
949
raise AssertionError(
950
"cannot cleanly remove existing _fallback_repositories")
951
for fb in self._fallback_repositories:
952
self._real_repository.add_fallback_repository(fb)
953
if self._lock_mode == 'w':
954
# if we are already locked, the real repository must be able to
955
# acquire the lock with our token.
956
self._real_repository.lock_write(self._lock_token)
957
elif self._lock_mode == 'r':
958
self._real_repository.lock_read()
960
def start_write_group(self):
961
"""Start a write group on the decorated repository.
963
Smart methods perform operations in a single step so this API
964
is not really applicable except as a compatibility thunk
965
for older plugins that don't use e.g. the CommitBuilder
969
return self._real_repository.start_write_group()
971
def _unlock(self, token):
972
path = self.bzrdir._path_for_remote_call(self._client)
974
# with no token the remote repository is not persistently locked.
976
err_context = {'token': token}
977
response = self._call('Repository.unlock', path, token,
979
if response == ('ok',):
982
raise errors.UnexpectedSmartServerResponse(response)
985
if not self._lock_count:
986
raise errors.LockNotHeld(self)
987
self._lock_count -= 1
988
if self._lock_count > 0:
990
self._unstacked_provider.disable_cache()
991
old_mode = self._lock_mode
992
self._lock_mode = None
994
# The real repository is responsible at present for raising an
995
# exception if it's in an unfinished write group. However, it
996
# normally will *not* actually remove the lock from disk - that's
997
# done by the server on receiving the Repository.unlock call.
998
# This is just to let the _real_repository stay up to date.
999
if self._real_repository is not None:
1000
self._real_repository.unlock()
1002
# The rpc-level lock should be released even if there was a
1003
# problem releasing the vfs-based lock.
1005
# Only write-locked repositories need to make a remote method
1006
# call to perform the unlock.
1007
old_token = self._lock_token
1008
self._lock_token = None
1009
if not self._leave_lock:
1010
self._unlock(old_token)
1012
def break_lock(self):
1013
# should hand off to the network
1015
return self._real_repository.break_lock()
1017
def _get_tarball(self, compression):
1018
"""Return a TemporaryFile containing a repository tarball.
1020
Returns None if the server does not support sending tarballs.
1023
path = self.bzrdir._path_for_remote_call(self._client)
1025
response, protocol = self._call_expecting_body(
1026
'Repository.tarball', path, compression)
1027
except errors.UnknownSmartMethod:
1028
protocol.cancel_read_body()
1030
if response[0] == 'ok':
1031
# Extract the tarball and return it
1032
t = tempfile.NamedTemporaryFile()
1033
# TODO: rpc layer should read directly into it...
1034
t.write(protocol.read_body_bytes())
1037
raise errors.UnexpectedSmartServerResponse(response)
1039
def sprout(self, to_bzrdir, revision_id=None):
1040
# TODO: Option to control what format is created?
1042
dest_repo = self._real_repository._format.initialize(to_bzrdir,
1044
dest_repo.fetch(self, revision_id=revision_id)
1047
### These methods are just thin shims to the VFS object for now.
1049
def revision_tree(self, revision_id):
1051
return self._real_repository.revision_tree(revision_id)
1053
def get_serializer_format(self):
1055
return self._real_repository.get_serializer_format()
1057
def get_commit_builder(self, branch, parents, config, timestamp=None,
1058
timezone=None, committer=None, revprops=None,
1060
# FIXME: It ought to be possible to call this without immediately
1061
# triggering _ensure_real. For now it's the easiest thing to do.
1063
real_repo = self._real_repository
1064
builder = real_repo.get_commit_builder(branch, parents,
1065
config, timestamp=timestamp, timezone=timezone,
1066
committer=committer, revprops=revprops, revision_id=revision_id)
1069
def add_fallback_repository(self, repository):
1070
"""Add a repository to use for looking up data not held locally.
1072
:param repository: A repository.
1074
if not self._format.supports_external_lookups:
1075
raise errors.UnstackableRepositoryFormat(
1076
self._format.network_name(), self.base)
1077
# We need to accumulate additional repositories here, to pass them in
1080
self._fallback_repositories.append(repository)
1081
# If self._real_repository was parameterised already (e.g. because a
1082
# _real_branch had its get_stacked_on_url method called), then the
1083
# repository to be added may already be in the _real_repositories list.
1084
if self._real_repository is not None:
1085
fallback_locations = [repo.bzrdir.root_transport.base for repo in
1086
self._real_repository._fallback_repositories]
1087
if repository.bzrdir.root_transport.base not in fallback_locations:
1088
self._real_repository.add_fallback_repository(repository)
1090
def add_inventory(self, revid, inv, parents):
1092
return self._real_repository.add_inventory(revid, inv, parents)
1094
def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1097
return self._real_repository.add_inventory_by_delta(basis_revision_id,
1098
delta, new_revision_id, parents)
1100
def add_revision(self, rev_id, rev, inv=None, config=None):
1102
return self._real_repository.add_revision(
1103
rev_id, rev, inv=inv, config=config)
1106
def get_inventory(self, revision_id):
1108
return self._real_repository.get_inventory(revision_id)
1110
def iter_inventories(self, revision_ids):
1112
return self._real_repository.iter_inventories(revision_ids)
1115
def get_revision(self, revision_id):
1117
return self._real_repository.get_revision(revision_id)
1119
def get_transaction(self):
1121
return self._real_repository.get_transaction()
1124
def clone(self, a_bzrdir, revision_id=None):
1126
return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
1128
def make_working_trees(self):
1129
"""See Repository.make_working_trees"""
1131
return self._real_repository.make_working_trees()
1133
def refresh_data(self):
1134
"""Re-read any data needed to to synchronise with disk.
1136
This method is intended to be called after another repository instance
1137
(such as one used by a smart server) has inserted data into the
1138
repository. It may not be called during a write group, but may be
1139
called at any other time.
1141
if self.is_in_write_group():
1142
raise errors.InternalBzrError(
1143
"May not refresh_data while in a write group.")
1144
if self._real_repository is not None:
1145
self._real_repository.refresh_data()
1147
def revision_ids_to_search_result(self, result_set):
1148
"""Convert a set of revision ids to a graph SearchResult."""
1149
result_parents = set()
1150
for parents in self.get_graph().get_parent_map(
1151
result_set).itervalues():
1152
result_parents.update(parents)
1153
included_keys = result_set.intersection(result_parents)
1154
start_keys = result_set.difference(included_keys)
1155
exclude_keys = result_parents.difference(result_set)
1156
result = graph.SearchResult(start_keys, exclude_keys,
1157
len(result_set), result_set)
1161
def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1162
"""Return the revision ids that other has that this does not.
1164
These are returned in topological order.
1166
revision_id: only return revision ids included by revision_id.
1168
return repository.InterRepository.get(
1169
other, self).search_missing_revision_ids(revision_id, find_ghosts)
1171
def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
1173
# No base implementation to use as RemoteRepository is not a subclass
1174
# of Repository; so this is a copy of Repository.fetch().
1175
if fetch_spec is not None and revision_id is not None:
1176
raise AssertionError(
1177
"fetch_spec and revision_id are mutually exclusive.")
1178
if self.is_in_write_group():
1179
raise errors.InternalBzrError(
1180
"May not fetch while in a write group.")
1181
# fast path same-url fetch operations
1182
if self.has_same_location(source) and fetch_spec is None:
1183
# check that last_revision is in 'from' and then return a
1185
if (revision_id is not None and
1186
not revision.is_null(revision_id)):
1187
self.get_revision(revision_id)
1189
# if there is no specific appropriate InterRepository, this will get
1190
# the InterRepository base class, which raises an
1191
# IncompatibleRepositories when asked to fetch.
1192
inter = repository.InterRepository.get(source, self)
1193
return inter.fetch(revision_id=revision_id, pb=pb,
1194
find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1196
def create_bundle(self, target, base, fileobj, format=None):
1198
self._real_repository.create_bundle(target, base, fileobj, format)
1201
def get_ancestry(self, revision_id, topo_sorted=True):
1203
return self._real_repository.get_ancestry(revision_id, topo_sorted)
1205
def fileids_altered_by_revision_ids(self, revision_ids):
1207
return self._real_repository.fileids_altered_by_revision_ids(revision_ids)
1209
def _get_versioned_file_checker(self, revisions, revision_versions_cache):
1211
return self._real_repository._get_versioned_file_checker(
1212
revisions, revision_versions_cache)
1214
def iter_files_bytes(self, desired_files):
1215
"""See Repository.iter_file_bytes.
1218
return self._real_repository.iter_files_bytes(desired_files)
1220
def get_parent_map(self, revision_ids):
1221
"""See bzrlib.Graph.get_parent_map()."""
1222
return self._make_parents_provider().get_parent_map(revision_ids)
1224
def _get_parent_map_rpc(self, keys):
1225
"""Helper for get_parent_map that performs the RPC."""
1226
medium = self._client._medium
1227
if medium._is_remote_before((1, 2)):
1228
# We already found out that the server can't understand
1229
# Repository.get_parent_map requests, so just fetch the whole
1232
# Note that this reads the whole graph, when only some keys are
1233
# wanted. On this old server there's no way (?) to get them all
1234
# in one go, and the user probably will have seen a warning about
1235
# the server being old anyhow.
1236
rg = self._get_revision_graph(None)
1237
# There is an API discrepancy between get_parent_map and
1238
# get_revision_graph. Specifically, a "key:()" pair in
1239
# get_revision_graph just means a node has no parents. For
1240
# "get_parent_map" it means the node is a ghost. So fix up the
1241
# graph to correct this.
1242
# https://bugs.launchpad.net/bzr/+bug/214894
1243
# There is one other "bug" which is that ghosts in
1244
# get_revision_graph() are not returned at all. But we won't worry
1245
# about that for now.
1246
for node_id, parent_ids in rg.iteritems():
1247
if parent_ids == ():
1248
rg[node_id] = (NULL_REVISION,)
1249
rg[NULL_REVISION] = ()
1254
raise ValueError('get_parent_map(None) is not valid')
1255
if NULL_REVISION in keys:
1256
keys.discard(NULL_REVISION)
1257
found_parents = {NULL_REVISION:()}
1259
return found_parents
1262
# TODO(Needs analysis): We could assume that the keys being requested
1263
# from get_parent_map are in a breadth first search, so typically they
1264
# will all be depth N from some common parent, and we don't have to
1265
# have the server iterate from the root parent, but rather from the
1266
# keys we're searching; and just tell the server the keyspace we
1267
# already have; but this may be more traffic again.
1269
# Transform self._parents_map into a search request recipe.
1270
# TODO: Manage this incrementally to avoid covering the same path
1271
# repeatedly. (The server will have to on each request, but the less
1272
# work done the better).
1274
# Negative caching notes:
1275
# new server sends missing when a request including the revid
1276
# 'include-missing:' is present in the request.
1277
# missing keys are serialised as missing:X, and we then call
1278
# provider.note_missing(X) for-all X
1279
parents_map = self._unstacked_provider.get_cached_map()
1280
if parents_map is None:
1281
# Repository is not locked, so there's no cache.
1283
# start_set is all the keys in the cache
1284
start_set = set(parents_map)
1285
# result set is all the references to keys in the cache
1286
result_parents = set()
1287
for parents in parents_map.itervalues():
1288
result_parents.update(parents)
1289
stop_keys = result_parents.difference(start_set)
1290
# We don't need to send ghosts back to the server as a position to
1292
stop_keys.difference_update(self._unstacked_provider.missing_keys)
1293
key_count = len(parents_map)
1294
if (NULL_REVISION in result_parents
1295
and NULL_REVISION in self._unstacked_provider.missing_keys):
1296
# If we pruned NULL_REVISION from the stop_keys because it's also
1297
# in our cache of "missing" keys we need to increment our key count
1298
# by 1, because the reconsitituted SearchResult on the server will
1299
# still consider NULL_REVISION to be an included key.
1301
included_keys = start_set.intersection(result_parents)
1302
start_set.difference_update(included_keys)
1303
recipe = ('manual', start_set, stop_keys, key_count)
1304
body = self._serialise_search_recipe(recipe)
1305
path = self.bzrdir._path_for_remote_call(self._client)
1307
if type(key) is not str:
1309
"key %r not a plain string" % (key,))
1310
verb = 'Repository.get_parent_map'
1311
args = (path, 'include-missing:') + tuple(keys)
1313
response = self._call_with_body_bytes_expecting_body(
1315
except errors.UnknownSmartMethod:
1316
# Server does not support this method, so get the whole graph.
1317
# Worse, we have to force a disconnection, because the server now
1318
# doesn't realise it has a body on the wire to consume, so the
1319
# only way to recover is to abandon the connection.
1321
'Server is too old for fast get_parent_map, reconnecting. '
1322
'(Upgrade the server to Bazaar 1.2 to avoid this)')
1324
# To avoid having to disconnect repeatedly, we keep track of the
1325
# fact the server doesn't understand remote methods added in 1.2.
1326
medium._remember_remote_is_before((1, 2))
1327
# Recurse just once and we should use the fallback code.
1328
return self._get_parent_map_rpc(keys)
1329
response_tuple, response_handler = response
1330
if response_tuple[0] not in ['ok']:
1331
response_handler.cancel_read_body()
1332
raise errors.UnexpectedSmartServerResponse(response_tuple)
1333
if response_tuple[0] == 'ok':
1334
coded = bz2.decompress(response_handler.read_body_bytes())
1336
# no revisions found
1338
lines = coded.split('\n')
1341
d = tuple(line.split())
1343
revision_graph[d[0]] = d[1:]
1346
if d[0].startswith('missing:'):
1348
self._unstacked_provider.note_missing_key(revid)
1350
# no parents - so give the Graph result
1352
revision_graph[d[0]] = (NULL_REVISION,)
1353
return revision_graph
1356
def get_signature_text(self, revision_id):
1358
return self._real_repository.get_signature_text(revision_id)
1361
def get_inventory_xml(self, revision_id):
1363
return self._real_repository.get_inventory_xml(revision_id)
1365
def deserialise_inventory(self, revision_id, xml):
1367
return self._real_repository.deserialise_inventory(revision_id, xml)
1369
def reconcile(self, other=None, thorough=False):
1371
return self._real_repository.reconcile(other=other, thorough=thorough)
1373
def all_revision_ids(self):
1375
return self._real_repository.all_revision_ids()
1378
def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1380
return self._real_repository.get_deltas_for_revisions(revisions,
1381
specific_fileids=specific_fileids)
1384
def get_revision_delta(self, revision_id, specific_fileids=None):
1386
return self._real_repository.get_revision_delta(revision_id,
1387
specific_fileids=specific_fileids)
1390
def revision_trees(self, revision_ids):
1392
return self._real_repository.revision_trees(revision_ids)
1395
def get_revision_reconcile(self, revision_id):
1397
return self._real_repository.get_revision_reconcile(revision_id)
1400
def check(self, revision_ids=None):
1402
return self._real_repository.check(revision_ids=revision_ids)
1404
def copy_content_into(self, destination, revision_id=None):
1406
return self._real_repository.copy_content_into(
1407
destination, revision_id=revision_id)
1409
def _copy_repository_tarball(self, to_bzrdir, revision_id=None):
1410
# get a tarball of the remote repository, and copy from that into the
1412
from bzrlib import osutils
1414
# TODO: Maybe a progress bar while streaming the tarball?
1415
note("Copying repository content as tarball...")
1416
tar_file = self._get_tarball('bz2')
1417
if tar_file is None:
1419
destination = to_bzrdir.create_repository()
1421
tar = tarfile.open('repository', fileobj=tar_file,
1423
tmpdir = osutils.mkdtemp()
1425
_extract_tar(tar, tmpdir)
1426
tmp_bzrdir = BzrDir.open(tmpdir)
1427
tmp_repo = tmp_bzrdir.open_repository()
1428
tmp_repo.copy_content_into(destination, revision_id)
1430
osutils.rmtree(tmpdir)
1434
# TODO: Suggestion from john: using external tar is much faster than
1435
# python's tarfile library, but it may not work on windows.
1438
def inventories(self):
1439
"""Decorate the real repository for now.
1441
In the long term a full blown network facility is needed to
1442
avoid creating a real repository object locally.
1445
return self._real_repository.inventories
1449
"""Compress the data within the repository.
1451
This is not currently implemented within the smart server.
1454
return self._real_repository.pack()
1457
def revisions(self):
1458
"""Decorate the real repository for now.
1460
In the short term this should become a real object to intercept graph
1463
In the long term a full blown network facility is needed.
1466
return self._real_repository.revisions
1468
def set_make_working_trees(self, new_value):
1470
new_value_str = "True"
1472
new_value_str = "False"
1473
path = self.bzrdir._path_for_remote_call(self._client)
1475
response = self._call(
1476
'Repository.set_make_working_trees', path, new_value_str)
1477
except errors.UnknownSmartMethod:
1479
self._real_repository.set_make_working_trees(new_value)
1481
if response[0] != 'ok':
1482
raise errors.UnexpectedSmartServerResponse(response)
1485
def signatures(self):
1486
"""Decorate the real repository for now.
1488
In the long term a full blown network facility is needed to avoid
1489
creating a real repository object locally.
1492
return self._real_repository.signatures
1495
def sign_revision(self, revision_id, gpg_strategy):
1497
return self._real_repository.sign_revision(revision_id, gpg_strategy)
1501
"""Decorate the real repository for now.
1503
In the long term a full blown network facility is needed to avoid
1504
creating a real repository object locally.
1507
return self._real_repository.texts
1510
def get_revisions(self, revision_ids):
1512
return self._real_repository.get_revisions(revision_ids)
1514
def supports_rich_root(self):
1515
return self._format.rich_root_data
1517
def iter_reverse_revision_history(self, revision_id):
1519
return self._real_repository.iter_reverse_revision_history(revision_id)
1522
def _serializer(self):
1523
return self._format._serializer
1525
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1527
return self._real_repository.store_revision_signature(
1528
gpg_strategy, plaintext, revision_id)
1530
def add_signature_text(self, revision_id, signature):
1532
return self._real_repository.add_signature_text(revision_id, signature)
1534
def has_signature_for_revision_id(self, revision_id):
1536
return self._real_repository.has_signature_for_revision_id(revision_id)
1538
def item_keys_introduced_by(self, revision_ids, _files_pb=None):
1540
return self._real_repository.item_keys_introduced_by(revision_ids,
1541
_files_pb=_files_pb)
1543
def revision_graph_can_have_wrong_parents(self):
1544
# The answer depends on the remote repo format.
1546
return self._real_repository.revision_graph_can_have_wrong_parents()
1548
def _find_inconsistent_revision_parents(self):
1550
return self._real_repository._find_inconsistent_revision_parents()
1552
def _check_for_inconsistent_revision_parents(self):
1554
return self._real_repository._check_for_inconsistent_revision_parents()
1556
def _make_parents_provider(self, other=None):
1557
providers = [self._unstacked_provider]
1558
if other is not None:
1559
providers.insert(0, other)
1560
providers.extend(r._make_parents_provider() for r in
1561
self._fallback_repositories)
1562
return graph._StackedParentsProvider(providers)
1564
def _serialise_search_recipe(self, recipe):
1565
"""Serialise a graph search recipe.
1567
:param recipe: A search recipe (start, stop, count).
1568
:return: Serialised bytes.
1570
start_keys = ' '.join(recipe[1])
1571
stop_keys = ' '.join(recipe[2])
1572
count = str(recipe[3])
1573
return '\n'.join((start_keys, stop_keys, count))
1575
def _serialise_search_result(self, search_result):
1576
if isinstance(search_result, graph.PendingAncestryResult):
1577
parts = ['ancestry-of']
1578
parts.extend(search_result.heads)
1580
recipe = search_result.get_recipe()
1581
parts = [recipe[0], self._serialise_search_recipe(recipe)]
1582
return '\n'.join(parts)
1585
path = self.bzrdir._path_for_remote_call(self._client)
1587
response = self._call('PackRepository.autopack', path)
1588
except errors.UnknownSmartMethod:
1590
self._real_repository._pack_collection.autopack()
1593
if response[0] != 'ok':
1594
raise errors.UnexpectedSmartServerResponse(response)
1597
class RemoteStreamSink(repository.StreamSink):
1599
def _insert_real(self, stream, src_format, resume_tokens):
1600
self.target_repo._ensure_real()
1601
sink = self.target_repo._real_repository._get_sink()
1602
result = sink.insert_stream(stream, src_format, resume_tokens)
1604
self.target_repo.autopack()
1607
def insert_stream(self, stream, src_format, resume_tokens):
1608
target = self.target_repo
1609
if target._lock_token:
1610
verb = 'Repository.insert_stream_locked'
1611
extra_args = (target._lock_token or '',)
1612
required_version = (1, 14)
1614
verb = 'Repository.insert_stream'
1616
required_version = (1, 13)
1617
client = target._client
1618
medium = client._medium
1619
if medium._is_remote_before(required_version):
1620
# No possible way this can work.
1621
return self._insert_real(stream, src_format, resume_tokens)
1622
path = target.bzrdir._path_for_remote_call(client)
1623
if not resume_tokens:
1624
# XXX: Ugly but important for correctness, *will* be fixed during
1625
# 1.13 cycle. Pushing a stream that is interrupted results in a
1626
# fallback to the _real_repositories sink *with a partial stream*.
1627
# Thats bad because we insert less data than bzr expected. To avoid
1628
# this we do a trial push to make sure the verb is accessible, and
1629
# do not fallback when actually pushing the stream. A cleanup patch
1630
# is going to look at rewinding/restarting the stream/partial
1632
byte_stream = smart_repo._stream_to_byte_stream([], src_format)
1634
response = client.call_with_body_stream(
1635
(verb, path, '') + extra_args, byte_stream)
1636
except errors.UnknownSmartMethod:
1637
medium._remember_remote_is_before(required_version)
1638
return self._insert_real(stream, src_format, resume_tokens)
1639
byte_stream = smart_repo._stream_to_byte_stream(
1641
resume_tokens = ' '.join(resume_tokens)
1642
response = client.call_with_body_stream(
1643
(verb, path, resume_tokens) + extra_args, byte_stream)
1644
if response[0][0] not in ('ok', 'missing-basis'):
1645
raise errors.UnexpectedSmartServerResponse(response)
1646
if response[0][0] == 'missing-basis':
1647
tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1648
resume_tokens = tokens
1649
return resume_tokens, set(missing_keys)
1651
self.target_repo.refresh_data()
1655
class RemoteStreamSource(repository.StreamSource):
1656
"""Stream data from a remote server."""
1658
def get_stream(self, search):
1659
if (self.from_repository._fallback_repositories and
1660
self.to_format._fetch_order == 'topological'):
1661
return self._real_stream(self.from_repository, search)
1662
return self.missing_parents_chain(search, [self.from_repository] +
1663
self.from_repository._fallback_repositories)
1665
def _real_stream(self, repo, search):
1666
"""Get a stream for search from repo.
1668
This never called RemoteStreamSource.get_stream, and is a heler
1669
for RemoteStreamSource._get_stream to allow getting a stream
1670
reliably whether fallback back because of old servers or trying
1671
to stream from a non-RemoteRepository (which the stacked support
1674
source = repo._get_source(self.to_format)
1675
if isinstance(source, RemoteStreamSource):
1676
return repository.StreamSource.get_stream(source, search)
1677
return source.get_stream(search)
1679
def _get_stream(self, repo, search):
1680
"""Core worker to get a stream from repo for search.
1682
This is used by both get_stream and the stacking support logic. It
1683
deliberately gets a stream for repo which does not need to be
1684
self.from_repository. In the event that repo is not Remote, or
1685
cannot do a smart stream, a fallback is made to the generic
1686
repository._get_stream() interface, via self._real_stream.
1688
In the event of stacking, streams from _get_stream will not
1689
contain all the data for search - this is normal (see get_stream).
1691
:param repo: A repository.
1692
:param search: A search.
1694
# Fallbacks may be non-smart
1695
if not isinstance(repo, RemoteRepository):
1696
return self._real_stream(repo, search)
1697
client = repo._client
1698
medium = client._medium
1699
if medium._is_remote_before((1, 13)):
1700
# streaming was added in 1.13
1701
return self._real_stream(repo, search)
1702
path = repo.bzrdir._path_for_remote_call(client)
1704
search_bytes = repo._serialise_search_result(search)
1705
response = repo._call_with_body_bytes_expecting_body(
1706
'Repository.get_stream',
1707
(path, self.to_format.network_name()), search_bytes)
1708
response_tuple, response_handler = response
1709
except errors.UnknownSmartMethod:
1710
medium._remember_remote_is_before((1,13))
1711
return self._real_stream(repo, search)
1712
if response_tuple[0] != 'ok':
1713
raise errors.UnexpectedSmartServerResponse(response_tuple)
1714
byte_stream = response_handler.read_streamed_body()
1715
src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
1716
if src_format.network_name() != repo._format.network_name():
1717
raise AssertionError(
1718
"Mismatched RemoteRepository and stream src %r, %r" % (
1719
src_format.network_name(), repo._format.network_name()))
1722
def missing_parents_chain(self, search, sources):
1723
"""Chain multiple streams together to handle stacking.
1725
:param search: The overall search to satisfy with streams.
1726
:param sources: A list of Repository objects to query.
1728
self.serialiser = self.to_format._serializer
1729
self.seen_revs = set()
1730
self.referenced_revs = set()
1731
# If there are heads in the search, or the key count is > 0, we are not
1733
while not search.is_empty() and len(sources) > 1:
1734
source = sources.pop(0)
1735
stream = self._get_stream(source, search)
1736
for kind, substream in stream:
1737
if kind != 'revisions':
1738
yield kind, substream
1740
yield kind, self.missing_parents_rev_handler(substream)
1741
search = search.refine(self.seen_revs, self.referenced_revs)
1742
self.seen_revs = set()
1743
self.referenced_revs = set()
1744
if not search.is_empty():
1745
for kind, stream in self._get_stream(sources[0], search):
1748
def missing_parents_rev_handler(self, substream):
1749
for content in substream:
1750
revision_bytes = content.get_bytes_as('fulltext')
1751
revision = self.serialiser.read_revision_from_string(revision_bytes)
1752
self.seen_revs.add(content.key[-1])
1753
self.referenced_revs.update(revision.parent_ids)
1757
class RemoteBranchLockableFiles(LockableFiles):
1758
"""A 'LockableFiles' implementation that talks to a smart server.
1760
This is not a public interface class.
1763
def __init__(self, bzrdir, _client):
1764
self.bzrdir = bzrdir
1765
self._client = _client
1766
self._need_find_modes = True
1767
LockableFiles.__init__(
1768
self, bzrdir.get_branch_transport(None),
1769
'lock', lockdir.LockDir)
1771
def _find_modes(self):
1772
# RemoteBranches don't let the client set the mode of control files.
1773
self._dir_mode = None
1774
self._file_mode = None
1777
class RemoteBranchFormat(branch.BranchFormat):
1779
def __init__(self, network_name=None):
1780
super(RemoteBranchFormat, self).__init__()
1781
self._matchingbzrdir = RemoteBzrDirFormat()
1782
self._matchingbzrdir.set_branch_format(self)
1783
self._custom_format = None
1784
self._network_name = network_name
1786
def __eq__(self, other):
1787
return (isinstance(other, RemoteBranchFormat) and
1788
self.__dict__ == other.__dict__)
1790
def _ensure_real(self):
1791
if self._custom_format is None:
1792
self._custom_format = branch.network_format_registry.get(
1795
def get_format_description(self):
1796
return 'Remote BZR Branch'
1798
def network_name(self):
1799
return self._network_name
1801
def open(self, a_bzrdir, ignore_fallbacks=False):
1802
return a_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
1804
def _vfs_initialize(self, a_bzrdir):
1805
# Initialisation when using a local bzrdir object, or a non-vfs init
1806
# method is not available on the server.
1807
# self._custom_format is always set - the start of initialize ensures
1809
if isinstance(a_bzrdir, RemoteBzrDir):
1810
a_bzrdir._ensure_real()
1811
result = self._custom_format.initialize(a_bzrdir._real_bzrdir)
1813
# We assume the bzrdir is parameterised; it may not be.
1814
result = self._custom_format.initialize(a_bzrdir)
1815
if (isinstance(a_bzrdir, RemoteBzrDir) and
1816
not isinstance(result, RemoteBranch)):
1817
result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result)
1820
def initialize(self, a_bzrdir):
1821
# 1) get the network name to use.
1822
if self._custom_format:
1823
network_name = self._custom_format.network_name()
1825
# Select the current bzrlib default and ask for that.
1826
reference_bzrdir_format = bzrdir.format_registry.get('default')()
1827
reference_format = reference_bzrdir_format.get_branch_format()
1828
self._custom_format = reference_format
1829
network_name = reference_format.network_name()
1830
# Being asked to create on a non RemoteBzrDir:
1831
if not isinstance(a_bzrdir, RemoteBzrDir):
1832
return self._vfs_initialize(a_bzrdir)
1833
medium = a_bzrdir._client._medium
1834
if medium._is_remote_before((1, 13)):
1835
return self._vfs_initialize(a_bzrdir)
1836
# Creating on a remote bzr dir.
1837
# 2) try direct creation via RPC
1838
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
1839
verb = 'BzrDir.create_branch'
1841
response = a_bzrdir._call(verb, path, network_name)
1842
except errors.UnknownSmartMethod:
1843
# Fallback - use vfs methods
1844
medium._remember_remote_is_before((1, 13))
1845
return self._vfs_initialize(a_bzrdir)
1846
if response[0] != 'ok':
1847
raise errors.UnexpectedSmartServerResponse(response)
1848
# Turn the response into a RemoteRepository object.
1849
format = RemoteBranchFormat(network_name=response[1])
1850
repo_format = response_tuple_to_repo_format(response[3:])
1851
if response[2] == '':
1852
repo_bzrdir = a_bzrdir
1854
repo_bzrdir = RemoteBzrDir(
1855
a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
1857
remote_repo = RemoteRepository(repo_bzrdir, repo_format)
1858
remote_branch = RemoteBranch(a_bzrdir, remote_repo,
1859
format=format, setup_stacking=False)
1860
# XXX: We know this is a new branch, so it must have revno 0, revid
1861
# NULL_REVISION. Creating the branch locked would make this be unable
1862
# to be wrong; here its simply very unlikely to be wrong. RBC 20090225
1863
remote_branch._last_revision_info_cache = 0, NULL_REVISION
1864
return remote_branch
1866
def make_tags(self, branch):
1868
return self._custom_format.make_tags(branch)
1870
def supports_tags(self):
1871
# Remote branches might support tags, but we won't know until we
1872
# access the real remote branch.
1874
return self._custom_format.supports_tags()
1876
def supports_stacking(self):
1878
return self._custom_format.supports_stacking()
1881
class RemoteBranch(branch.Branch, _RpcHelper):
1882
"""Branch stored on a server accessed by HPSS RPC.
1884
At the moment most operations are mapped down to simple file operations.
1887
def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
1888
_client=None, format=None, setup_stacking=True):
1889
"""Create a RemoteBranch instance.
1891
:param real_branch: An optional local implementation of the branch
1892
format, usually accessing the data via the VFS.
1893
:param _client: Private parameter for testing.
1894
:param format: A RemoteBranchFormat object, None to create one
1895
automatically. If supplied it should have a network_name already
1897
:param setup_stacking: If True make an RPC call to determine the
1898
stacked (or not) status of the branch. If False assume the branch
1901
# We intentionally don't call the parent class's __init__, because it
1902
# will try to assign to self.tags, which is a property in this subclass.
1903
# And the parent's __init__ doesn't do much anyway.
1904
self._revision_id_to_revno_cache = None
1905
self._partial_revision_id_to_revno_cache = {}
1906
self._revision_history_cache = None
1907
self._last_revision_info_cache = None
1908
self._merge_sorted_revisions_cache = None
1909
self.bzrdir = remote_bzrdir
1910
if _client is not None:
1911
self._client = _client
1913
self._client = remote_bzrdir._client
1914
self.repository = remote_repository
1915
if real_branch is not None:
1916
self._real_branch = real_branch
1917
# Give the remote repository the matching real repo.
1918
real_repo = self._real_branch.repository
1919
if isinstance(real_repo, RemoteRepository):
1920
real_repo._ensure_real()
1921
real_repo = real_repo._real_repository
1922
self.repository._set_real_repository(real_repo)
1923
# Give the branch the remote repository to let fast-pathing happen.
1924
self._real_branch.repository = self.repository
1926
self._real_branch = None
1927
# Fill out expected attributes of branch for bzrlib API users.
1928
self.base = self.bzrdir.root_transport.base
1929
self._control_files = None
1930
self._lock_mode = None
1931
self._lock_token = None
1932
self._repo_lock_token = None
1933
self._lock_count = 0
1934
self._leave_lock = False
1935
# Setup a format: note that we cannot call _ensure_real until all the
1936
# attributes above are set: This code cannot be moved higher up in this
1939
self._format = RemoteBranchFormat()
1940
if real_branch is not None:
1941
self._format._network_name = \
1942
self._real_branch._format.network_name()
1944
self._format = format
1945
if not self._format._network_name:
1946
# Did not get from open_branchV2 - old server.
1948
self._format._network_name = \
1949
self._real_branch._format.network_name()
1950
self.tags = self._format.make_tags(self)
1951
# The base class init is not called, so we duplicate this:
1952
hooks = branch.Branch.hooks['open']
1956
self._setup_stacking()
1958
def _setup_stacking(self):
1959
# configure stacking into the remote repository, by reading it from
1962
fallback_url = self.get_stacked_on_url()
1963
except (errors.NotStacked, errors.UnstackableBranchFormat,
1964
errors.UnstackableRepositoryFormat), e:
1966
self._activate_fallback_location(fallback_url, None)
1968
def _get_config(self):
1969
return RemoteBranchConfig(self)
1971
def _get_real_transport(self):
1972
# if we try vfs access, return the real branch's vfs transport
1974
return self._real_branch._transport
1976
_transport = property(_get_real_transport)
1979
return "%s(%s)" % (self.__class__.__name__, self.base)
1983
def _ensure_real(self):
1984
"""Ensure that there is a _real_branch set.
1986
Used before calls to self._real_branch.
1988
if self._real_branch is None:
1989
if not vfs.vfs_enabled():
1990
raise AssertionError('smart server vfs must be enabled '
1991
'to use vfs implementation')
1992
self.bzrdir._ensure_real()
1993
self._real_branch = self.bzrdir._real_bzrdir.open_branch()
1994
if self.repository._real_repository is None:
1995
# Give the remote repository the matching real repo.
1996
real_repo = self._real_branch.repository
1997
if isinstance(real_repo, RemoteRepository):
1998
real_repo._ensure_real()
1999
real_repo = real_repo._real_repository
2000
self.repository._set_real_repository(real_repo)
2001
# Give the real branch the remote repository to let fast-pathing
2003
self._real_branch.repository = self.repository
2004
if self._lock_mode == 'r':
2005
self._real_branch.lock_read()
2006
elif self._lock_mode == 'w':
2007
self._real_branch.lock_write(token=self._lock_token)
2009
def _translate_error(self, err, **context):
2010
self.repository._translate_error(err, branch=self, **context)
2012
def _clear_cached_state(self):
2013
super(RemoteBranch, self)._clear_cached_state()
2014
if self._real_branch is not None:
2015
self._real_branch._clear_cached_state()
2017
def _clear_cached_state_of_remote_branch_only(self):
2018
"""Like _clear_cached_state, but doesn't clear the cache of
2021
This is useful when falling back to calling a method of
2022
self._real_branch that changes state. In that case the underlying
2023
branch changes, so we need to invalidate this RemoteBranch's cache of
2024
it. However, there's no need to invalidate the _real_branch's cache
2025
too, in fact doing so might harm performance.
2027
super(RemoteBranch, self)._clear_cached_state()
2030
def control_files(self):
2031
# Defer actually creating RemoteBranchLockableFiles until its needed,
2032
# because it triggers an _ensure_real that we otherwise might not need.
2033
if self._control_files is None:
2034
self._control_files = RemoteBranchLockableFiles(
2035
self.bzrdir, self._client)
2036
return self._control_files
2038
def _get_checkout_format(self):
2040
return self._real_branch._get_checkout_format()
2042
def get_physical_lock_status(self):
2043
"""See Branch.get_physical_lock_status()."""
2044
# should be an API call to the server, as branches must be lockable.
2046
return self._real_branch.get_physical_lock_status()
2048
def get_stacked_on_url(self):
2049
"""Get the URL this branch is stacked against.
2051
:raises NotStacked: If the branch is not stacked.
2052
:raises UnstackableBranchFormat: If the branch does not support
2054
:raises UnstackableRepositoryFormat: If the repository does not support
2058
# there may not be a repository yet, so we can't use
2059
# self._translate_error, so we can't use self._call either.
2060
response = self._client.call('Branch.get_stacked_on_url',
2061
self._remote_path())
2062
except errors.ErrorFromSmartServer, err:
2063
# there may not be a repository yet, so we can't call through
2064
# its _translate_error
2065
_translate_error(err, branch=self)
2066
except errors.UnknownSmartMethod, err:
2068
return self._real_branch.get_stacked_on_url()
2069
if response[0] != 'ok':
2070
raise errors.UnexpectedSmartServerResponse(response)
2073
def _vfs_get_tags_bytes(self):
2075
return self._real_branch._get_tags_bytes()
2077
def _get_tags_bytes(self):
2078
medium = self._client._medium
2079
if medium._is_remote_before((1, 13)):
2080
return self._vfs_get_tags_bytes()
2082
response = self._call('Branch.get_tags_bytes', self._remote_path())
2083
except errors.UnknownSmartMethod:
2084
medium._remember_remote_is_before((1, 13))
2085
return self._vfs_get_tags_bytes()
2088
def lock_read(self):
2089
self.repository.lock_read()
2090
if not self._lock_mode:
2091
self._lock_mode = 'r'
2092
self._lock_count = 1
2093
if self._real_branch is not None:
2094
self._real_branch.lock_read()
2096
self._lock_count += 1
2098
def _remote_lock_write(self, token):
2100
branch_token = repo_token = ''
2102
branch_token = token
2103
repo_token = self.repository.lock_write()
2104
self.repository.unlock()
2105
err_context = {'token': token}
2106
response = self._call(
2107
'Branch.lock_write', self._remote_path(), branch_token,
2108
repo_token or '', **err_context)
2109
if response[0] != 'ok':
2110
raise errors.UnexpectedSmartServerResponse(response)
2111
ok, branch_token, repo_token = response
2112
return branch_token, repo_token
2114
def lock_write(self, token=None):
2115
if not self._lock_mode:
2116
# Lock the branch and repo in one remote call.
2117
remote_tokens = self._remote_lock_write(token)
2118
self._lock_token, self._repo_lock_token = remote_tokens
2119
if not self._lock_token:
2120
raise SmartProtocolError('Remote server did not return a token!')
2121
# Tell the self.repository object that it is locked.
2122
self.repository.lock_write(
2123
self._repo_lock_token, _skip_rpc=True)
2125
if self._real_branch is not None:
2126
self._real_branch.lock_write(token=self._lock_token)
2127
if token is not None:
2128
self._leave_lock = True
2130
self._leave_lock = False
2131
self._lock_mode = 'w'
2132
self._lock_count = 1
2133
elif self._lock_mode == 'r':
2134
raise errors.ReadOnlyTransaction
2136
if token is not None:
2137
# A token was given to lock_write, and we're relocking, so
2138
# check that the given token actually matches the one we
2140
if token != self._lock_token:
2141
raise errors.TokenMismatch(token, self._lock_token)
2142
self._lock_count += 1
2143
# Re-lock the repository too.
2144
self.repository.lock_write(self._repo_lock_token)
2145
return self._lock_token or None
2147
def _set_tags_bytes(self, bytes):
2149
return self._real_branch._set_tags_bytes(bytes)
2151
def _unlock(self, branch_token, repo_token):
2152
err_context = {'token': str((branch_token, repo_token))}
2153
response = self._call(
2154
'Branch.unlock', self._remote_path(), branch_token,
2155
repo_token or '', **err_context)
2156
if response == ('ok',):
2158
raise errors.UnexpectedSmartServerResponse(response)
2162
self._lock_count -= 1
2163
if not self._lock_count:
2164
self._clear_cached_state()
2165
mode = self._lock_mode
2166
self._lock_mode = None
2167
if self._real_branch is not None:
2168
if (not self._leave_lock and mode == 'w' and
2169
self._repo_lock_token):
2170
# If this RemoteBranch will remove the physical lock
2171
# for the repository, make sure the _real_branch
2172
# doesn't do it first. (Because the _real_branch's
2173
# repository is set to be the RemoteRepository.)
2174
self._real_branch.repository.leave_lock_in_place()
2175
self._real_branch.unlock()
2177
# Only write-locked branched need to make a remote method
2178
# call to perform the unlock.
2180
if not self._lock_token:
2181
raise AssertionError('Locked, but no token!')
2182
branch_token = self._lock_token
2183
repo_token = self._repo_lock_token
2184
self._lock_token = None
2185
self._repo_lock_token = None
2186
if not self._leave_lock:
2187
self._unlock(branch_token, repo_token)
2189
self.repository.unlock()
2191
def break_lock(self):
2193
return self._real_branch.break_lock()
2195
def leave_lock_in_place(self):
2196
if not self._lock_token:
2197
raise NotImplementedError(self.leave_lock_in_place)
2198
self._leave_lock = True
2200
def dont_leave_lock_in_place(self):
2201
if not self._lock_token:
2202
raise NotImplementedError(self.dont_leave_lock_in_place)
2203
self._leave_lock = False
2205
def _last_revision_info(self):
2206
response = self._call('Branch.last_revision_info', self._remote_path())
2207
if response[0] != 'ok':
2208
raise SmartProtocolError('unexpected response code %s' % (response,))
2209
revno = int(response[1])
2210
last_revision = response[2]
2211
return (revno, last_revision)
2213
def _gen_revision_history(self):
2214
"""See Branch._gen_revision_history()."""
2215
response_tuple, response_handler = self._call_expecting_body(
2216
'Branch.revision_history', self._remote_path())
2217
if response_tuple[0] != 'ok':
2218
raise errors.UnexpectedSmartServerResponse(response_tuple)
2219
result = response_handler.read_body_bytes().split('\x00')
2224
def _remote_path(self):
2225
return self.bzrdir._path_for_remote_call(self._client)
2227
def _set_last_revision_descendant(self, revision_id, other_branch,
2228
allow_diverged=False, allow_overwrite_descendant=False):
2229
# This performs additional work to meet the hook contract; while its
2230
# undesirable, we have to synthesise the revno to call the hook, and
2231
# not calling the hook is worse as it means changes can't be prevented.
2232
# Having calculated this though, we can't just call into
2233
# set_last_revision_info as a simple call, because there is a set_rh
2234
# hook that some folk may still be using.
2235
old_revno, old_revid = self.last_revision_info()
2236
history = self._lefthand_history(revision_id)
2237
self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2238
err_context = {'other_branch': other_branch}
2239
response = self._call('Branch.set_last_revision_ex',
2240
self._remote_path(), self._lock_token, self._repo_lock_token,
2241
revision_id, int(allow_diverged), int(allow_overwrite_descendant),
2243
self._clear_cached_state()
2244
if len(response) != 3 and response[0] != 'ok':
2245
raise errors.UnexpectedSmartServerResponse(response)
2246
new_revno, new_revision_id = response[1:]
2247
self._last_revision_info_cache = new_revno, new_revision_id
2248
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2249
if self._real_branch is not None:
2250
cache = new_revno, new_revision_id
2251
self._real_branch._last_revision_info_cache = cache
2253
def _set_last_revision(self, revision_id):
2254
old_revno, old_revid = self.last_revision_info()
2255
# This performs additional work to meet the hook contract; while its
2256
# undesirable, we have to synthesise the revno to call the hook, and
2257
# not calling the hook is worse as it means changes can't be prevented.
2258
# Having calculated this though, we can't just call into
2259
# set_last_revision_info as a simple call, because there is a set_rh
2260
# hook that some folk may still be using.
2261
history = self._lefthand_history(revision_id)
2262
self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2263
self._clear_cached_state()
2264
response = self._call('Branch.set_last_revision',
2265
self._remote_path(), self._lock_token, self._repo_lock_token,
2267
if response != ('ok',):
2268
raise errors.UnexpectedSmartServerResponse(response)
2269
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2272
def set_revision_history(self, rev_history):
2273
# Send just the tip revision of the history; the server will generate
2274
# the full history from that. If the revision doesn't exist in this
2275
# branch, NoSuchRevision will be raised.
2276
if rev_history == []:
2279
rev_id = rev_history[-1]
2280
self._set_last_revision(rev_id)
2281
for hook in branch.Branch.hooks['set_rh']:
2282
hook(self, rev_history)
2283
self._cache_revision_history(rev_history)
2285
def _get_parent_location(self):
2286
medium = self._client._medium
2287
if medium._is_remote_before((1, 13)):
2288
return self._vfs_get_parent_location()
2290
response = self._call('Branch.get_parent', self._remote_path())
2291
except errors.UnknownSmartMethod:
2292
medium._remember_remote_is_before((1, 13))
2293
return self._vfs_get_parent_location()
2294
if len(response) != 1:
2295
raise errors.UnexpectedSmartServerResponse(response)
2296
parent_location = response[0]
2297
if parent_location == '':
2299
return parent_location
2301
def _vfs_get_parent_location(self):
2303
return self._real_branch._get_parent_location()
2305
def _set_parent_location(self, url):
2306
medium = self._client._medium
2307
if medium._is_remote_before((1, 15)):
2308
return self._vfs_set_parent_location(url)
2310
call_url = url or ''
2311
if type(call_url) is not str:
2312
raise AssertionError('url must be a str or None (%s)' % url)
2313
response = self._call('Branch.set_parent_location',
2314
self._remote_path(), self._lock_token, self._repo_lock_token,
2316
except errors.UnknownSmartMethod:
2317
medium._remember_remote_is_before((1, 15))
2318
return self._vfs_set_parent_location(url)
2320
raise errors.UnexpectedSmartServerResponse(response)
2322
def _vfs_set_parent_location(self, url):
2324
return self._real_branch._set_parent_location(url)
2327
def pull(self, source, overwrite=False, stop_revision=None,
2329
self._clear_cached_state_of_remote_branch_only()
2331
return self._real_branch.pull(
2332
source, overwrite=overwrite, stop_revision=stop_revision,
2333
_override_hook_target=self, **kwargs)
2336
def push(self, target, overwrite=False, stop_revision=None):
2338
return self._real_branch.push(
2339
target, overwrite=overwrite, stop_revision=stop_revision,
2340
_override_hook_source_branch=self)
2342
def is_locked(self):
2343
return self._lock_count >= 1
2346
def revision_id_to_revno(self, revision_id):
2348
return self._real_branch.revision_id_to_revno(revision_id)
2351
def set_last_revision_info(self, revno, revision_id):
2352
# XXX: These should be returned by the set_last_revision_info verb
2353
old_revno, old_revid = self.last_revision_info()
2354
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2355
revision_id = ensure_null(revision_id)
2357
response = self._call('Branch.set_last_revision_info',
2358
self._remote_path(), self._lock_token, self._repo_lock_token,
2359
str(revno), revision_id)
2360
except errors.UnknownSmartMethod:
2362
self._clear_cached_state_of_remote_branch_only()
2363
self._real_branch.set_last_revision_info(revno, revision_id)
2364
self._last_revision_info_cache = revno, revision_id
2366
if response == ('ok',):
2367
self._clear_cached_state()
2368
self._last_revision_info_cache = revno, revision_id
2369
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2370
# Update the _real_branch's cache too.
2371
if self._real_branch is not None:
2372
cache = self._last_revision_info_cache
2373
self._real_branch._last_revision_info_cache = cache
2375
raise errors.UnexpectedSmartServerResponse(response)
2378
def generate_revision_history(self, revision_id, last_rev=None,
2380
medium = self._client._medium
2381
if not medium._is_remote_before((1, 6)):
2382
# Use a smart method for 1.6 and above servers
2384
self._set_last_revision_descendant(revision_id, other_branch,
2385
allow_diverged=True, allow_overwrite_descendant=True)
2387
except errors.UnknownSmartMethod:
2388
medium._remember_remote_is_before((1, 6))
2389
self._clear_cached_state_of_remote_branch_only()
2390
self.set_revision_history(self._lefthand_history(revision_id,
2391
last_rev=last_rev,other_branch=other_branch))
2393
def set_push_location(self, location):
2395
return self._real_branch.set_push_location(location)
2398
class RemoteConfig(object):
2399
"""A Config that reads and writes from smart verbs.
2401
It is a low-level object that considers config data to be name/value pairs
2402
that may be associated with a section. Assigning meaning to the these
2403
values is done at higher levels like bzrlib.config.TreeConfig.
2406
def get_option(self, name, section=None, default=None):
2407
"""Return the value associated with a named option.
2409
:param name: The name of the value
2410
:param section: The section the option is in (if any)
2411
:param default: The value to return if the value is not set
2412
:return: The value or default value
2415
configobj = self._get_configobj()
2417
section_obj = configobj
2420
section_obj = configobj[section]
2423
return section_obj.get(name, default)
2424
except errors.UnknownSmartMethod:
2425
return self._vfs_get_option(name, section, default)
2427
def _response_to_configobj(self, response):
2428
if len(response[0]) and response[0][0] != 'ok':
2429
raise errors.UnexpectedSmartServerResponse(response)
2430
lines = response[1].read_body_bytes().splitlines()
2431
return config.ConfigObj(lines, encoding='utf-8')
2434
class RemoteBranchConfig(RemoteConfig):
2435
"""A RemoteConfig for Branches."""
2437
def __init__(self, branch):
2438
self._branch = branch
2440
def _get_configobj(self):
2441
path = self._branch._remote_path()
2442
response = self._branch._client.call_expecting_body(
2443
'Branch.get_config_file', path)
2444
return self._response_to_configobj(response)
2446
def set_option(self, value, name, section=None):
2447
"""Set the value associated with a named option.
2449
:param value: The value to set
2450
:param name: The name of the value to set
2451
:param section: The section the option is in (if any)
2453
medium = self._branch._client._medium
2454
if medium._is_remote_before((1, 14)):
2455
return self._vfs_set_option(value, name, section)
2457
path = self._branch._remote_path()
2458
response = self._branch._client.call('Branch.set_config_option',
2459
path, self._branch._lock_token, self._branch._repo_lock_token,
2460
value.encode('utf8'), name, section or '')
2461
except errors.UnknownSmartMethod:
2462
medium._remember_remote_is_before((1, 14))
2463
return self._vfs_set_option(value, name, section)
2465
raise errors.UnexpectedSmartServerResponse(response)
2467
def _real_object(self):
2468
self._branch._ensure_real()
2469
return self._branch._real_branch
2471
def _vfs_set_option(self, value, name, section=None):
2472
return self._real_object()._get_config().set_option(
2473
value, name, section)
2476
class RemoteBzrDirConfig(RemoteConfig):
2477
"""A RemoteConfig for BzrDirs."""
2479
def __init__(self, bzrdir):
2480
self._bzrdir = bzrdir
2482
def _get_configobj(self):
2483
medium = self._bzrdir._client._medium
2484
verb = 'BzrDir.get_config_file'
2485
if medium._is_remote_before((1, 15)):
2486
raise errors.UnknownSmartMethod(verb)
2487
path = self._bzrdir._path_for_remote_call(self._bzrdir._client)
2488
response = self._bzrdir._call_expecting_body(
2490
return self._response_to_configobj(response)
2492
def _vfs_get_option(self, name, section, default):
2493
return self._real_object()._get_config().get_option(
2494
name, section, default)
2496
def set_option(self, value, name, section=None):
2497
"""Set the value associated with a named option.
2499
:param value: The value to set
2500
:param name: The name of the value to set
2501
:param section: The section the option is in (if any)
2503
return self._real_object()._get_config().set_option(
2504
value, name, section)
2506
def _real_object(self):
2507
self._bzrdir._ensure_real()
2508
return self._bzrdir._real_bzrdir
2512
def _extract_tar(tar, to_dir):
2513
"""Extract all the contents of a tarfile object.
2515
A replacement for extractall, which is not present in python2.4
2518
tar.extract(tarinfo, to_dir)
2521
def _translate_error(err, **context):
2522
"""Translate an ErrorFromSmartServer into a more useful error.
2524
Possible context keys:
2532
If the error from the server doesn't match a known pattern, then
2533
UnknownErrorFromSmartServer is raised.
2537
return context[name]
2538
except KeyError, key_err:
2539
mutter('Missing key %r in context %r', key_err.args[0], context)
2542
"""Get the path from the context if present, otherwise use first error
2546
return context['path']
2547
except KeyError, key_err:
2549
return err.error_args[0]
2550
except IndexError, idx_err:
2552
'Missing key %r in context %r', key_err.args[0], context)
2555
if err.error_verb == 'NoSuchRevision':
2556
raise NoSuchRevision(find('branch'), err.error_args[0])
2557
elif err.error_verb == 'nosuchrevision':
2558
raise NoSuchRevision(find('repository'), err.error_args[0])
2559
elif err.error_tuple == ('nobranch',):
2560
raise errors.NotBranchError(path=find('bzrdir').root_transport.base)
2561
elif err.error_verb == 'norepository':
2562
raise errors.NoRepositoryPresent(find('bzrdir'))
2563
elif err.error_verb == 'LockContention':
2564
raise errors.LockContention('(remote lock)')
2565
elif err.error_verb == 'UnlockableTransport':
2566
raise errors.UnlockableTransport(find('bzrdir').root_transport)
2567
elif err.error_verb == 'LockFailed':
2568
raise errors.LockFailed(err.error_args[0], err.error_args[1])
2569
elif err.error_verb == 'TokenMismatch':
2570
raise errors.TokenMismatch(find('token'), '(remote token)')
2571
elif err.error_verb == 'Diverged':
2572
raise errors.DivergedBranches(find('branch'), find('other_branch'))
2573
elif err.error_verb == 'TipChangeRejected':
2574
raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
2575
elif err.error_verb == 'UnstackableBranchFormat':
2576
raise errors.UnstackableBranchFormat(*err.error_args)
2577
elif err.error_verb == 'UnstackableRepositoryFormat':
2578
raise errors.UnstackableRepositoryFormat(*err.error_args)
2579
elif err.error_verb == 'NotStacked':
2580
raise errors.NotStacked(branch=find('branch'))
2581
elif err.error_verb == 'PermissionDenied':
2583
if len(err.error_args) >= 2:
2584
extra = err.error_args[1]
2587
raise errors.PermissionDenied(path, extra=extra)
2588
elif err.error_verb == 'ReadError':
2590
raise errors.ReadError(path)
2591
elif err.error_verb == 'NoSuchFile':
2593
raise errors.NoSuchFile(path)
2594
elif err.error_verb == 'FileExists':
2595
raise errors.FileExists(err.error_args[0])
2596
elif err.error_verb == 'DirectoryNotEmpty':
2597
raise errors.DirectoryNotEmpty(err.error_args[0])
2598
elif err.error_verb == 'ShortReadvError':
2599
args = err.error_args
2600
raise errors.ShortReadvError(
2601
args[0], int(args[1]), int(args[2]), int(args[3]))
2602
elif err.error_verb in ('UnicodeEncodeError', 'UnicodeDecodeError'):
2603
encoding = str(err.error_args[0]) # encoding must always be a string
2604
val = err.error_args[1]
2605
start = int(err.error_args[2])
2606
end = int(err.error_args[3])
2607
reason = str(err.error_args[4]) # reason must always be a string
2608
if val.startswith('u:'):
2609
val = val[2:].decode('utf-8')
2610
elif val.startswith('s:'):
2611
val = val[2:].decode('base64')
2612
if err.error_verb == 'UnicodeDecodeError':
2613
raise UnicodeDecodeError(encoding, val, start, end, reason)
2614
elif err.error_verb == 'UnicodeEncodeError':
2615
raise UnicodeEncodeError(encoding, val, start, end, reason)
2616
elif err.error_verb == 'ReadOnlyError':
2617
raise errors.TransportNotPossible('readonly transport')
2618
raise errors.UnknownErrorFromSmartServer(err)
added
removed
bzrlib/remote.py
