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 get_missing_parent_inventories(self):
672
return self._real_repository.get_missing_parent_inventories()
674
def _ensure_real(self):
675
"""Ensure that there is a _real_repository set.
677
Used before calls to self._real_repository.
679
Note that _ensure_real causes many roundtrips to the server which are
680
not desirable, and prevents the use of smart one-roundtrip RPC's to
681
perform complex operations (such as accessing parent data, streaming
682
revisions etc). Adding calls to _ensure_real should only be done when
683
bringing up new functionality, adding fallbacks for smart methods that
684
require a fallback path, and never to replace an existing smart method
685
invocation. If in doubt chat to the bzr network team.
687
if self._real_repository is None:
688
self.bzrdir._ensure_real()
689
self._set_real_repository(
690
self.bzrdir._real_bzrdir.open_repository())
692
def _translate_error(self, err, **context):
693
self.bzrdir._translate_error(err, repository=self, **context)
695
def find_text_key_references(self):
696
"""Find the text key references within the repository.
698
:return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
699
revision_ids. Each altered file-ids has the exact revision_ids that
700
altered it listed explicitly.
701
:return: A dictionary mapping text keys ((fileid, revision_id) tuples)
702
to whether they were referred to by the inventory of the
703
revision_id that they contain. The inventory texts from all present
704
revision ids are assessed to generate this report.
707
return self._real_repository.find_text_key_references()
709
def _generate_text_key_index(self):
710
"""Generate a new text key index for the repository.
712
This is an expensive function that will take considerable time to run.
714
:return: A dict mapping (file_id, revision_id) tuples to a list of
715
parents, also (file_id, revision_id) tuples.
718
return self._real_repository._generate_text_key_index()
720
def _get_revision_graph(self, revision_id):
721
"""Private method for using with old (< 1.2) servers to fallback."""
722
if revision_id is None:
724
elif revision.is_null(revision_id):
727
path = self.bzrdir._path_for_remote_call(self._client)
728
response = self._call_expecting_body(
729
'Repository.get_revision_graph', path, revision_id)
730
response_tuple, response_handler = response
731
if response_tuple[0] != 'ok':
732
raise errors.UnexpectedSmartServerResponse(response_tuple)
733
coded = response_handler.read_body_bytes()
735
# no revisions in this repository!
737
lines = coded.split('\n')
740
d = tuple(line.split())
741
revision_graph[d[0]] = d[1:]
743
return revision_graph
746
"""See Repository._get_sink()."""
747
return RemoteStreamSink(self)
749
def _get_source(self, to_format):
750
"""Return a source for streaming from this repository."""
751
return RemoteStreamSource(self, to_format)
753
def has_revision(self, revision_id):
754
"""See Repository.has_revision()."""
755
if revision_id == NULL_REVISION:
756
# The null revision is always present.
758
path = self.bzrdir._path_for_remote_call(self._client)
759
response = self._call('Repository.has_revision', path, revision_id)
760
if response[0] not in ('yes', 'no'):
761
raise errors.UnexpectedSmartServerResponse(response)
762
if response[0] == 'yes':
764
for fallback_repo in self._fallback_repositories:
765
if fallback_repo.has_revision(revision_id):
769
def has_revisions(self, revision_ids):
770
"""See Repository.has_revisions()."""
771
# FIXME: This does many roundtrips, particularly when there are
772
# fallback repositories. -- mbp 20080905
774
for revision_id in revision_ids:
775
if self.has_revision(revision_id):
776
result.add(revision_id)
779
def has_same_location(self, other):
780
return (self.__class__ is other.__class__ and
781
self.bzrdir.transport.base == other.bzrdir.transport.base)
783
def get_graph(self, other_repository=None):
784
"""Return the graph for this repository format"""
785
parents_provider = self._make_parents_provider(other_repository)
786
return graph.Graph(parents_provider)
788
def gather_stats(self, revid=None, committers=None):
789
"""See Repository.gather_stats()."""
790
path = self.bzrdir._path_for_remote_call(self._client)
791
# revid can be None to indicate no revisions, not just NULL_REVISION
792
if revid is None or revision.is_null(revid):
796
if committers is None or not committers:
797
fmt_committers = 'no'
799
fmt_committers = 'yes'
800
response_tuple, response_handler = self._call_expecting_body(
801
'Repository.gather_stats', path, fmt_revid, fmt_committers)
802
if response_tuple[0] != 'ok':
803
raise errors.UnexpectedSmartServerResponse(response_tuple)
805
body = response_handler.read_body_bytes()
807
for line in body.split('\n'):
810
key, val_text = line.split(':')
811
if key in ('revisions', 'size', 'committers'):
812
result[key] = int(val_text)
813
elif key in ('firstrev', 'latestrev'):
814
values = val_text.split(' ')[1:]
815
result[key] = (float(values[0]), long(values[1]))
819
def find_branches(self, using=False):
820
"""See Repository.find_branches()."""
821
# should be an API call to the server.
823
return self._real_repository.find_branches(using=using)
825
def get_physical_lock_status(self):
826
"""See Repository.get_physical_lock_status()."""
827
# should be an API call to the server.
829
return self._real_repository.get_physical_lock_status()
831
def is_in_write_group(self):
832
"""Return True if there is an open write group.
834
write groups are only applicable locally for the smart server..
836
if self._real_repository:
837
return self._real_repository.is_in_write_group()
840
return self._lock_count >= 1
843
"""See Repository.is_shared()."""
844
path = self.bzrdir._path_for_remote_call(self._client)
845
response = self._call('Repository.is_shared', path)
846
if response[0] not in ('yes', 'no'):
847
raise SmartProtocolError('unexpected response code %s' % (response,))
848
return response[0] == 'yes'
850
def is_write_locked(self):
851
return self._lock_mode == 'w'
854
# wrong eventually - want a local lock cache context
855
if not self._lock_mode:
856
self._lock_mode = 'r'
858
self._unstacked_provider.enable_cache(cache_misses=True)
859
if self._real_repository is not None:
860
self._real_repository.lock_read()
862
self._lock_count += 1
863
for repo in self._fallback_repositories:
866
def _remote_lock_write(self, token):
867
path = self.bzrdir._path_for_remote_call(self._client)
870
err_context = {'token': token}
871
response = self._call('Repository.lock_write', path, token,
873
if response[0] == 'ok':
877
raise errors.UnexpectedSmartServerResponse(response)
879
def lock_write(self, token=None, _skip_rpc=False):
880
if not self._lock_mode:
882
if self._lock_token is not None:
883
if token != self._lock_token:
884
raise errors.TokenMismatch(token, self._lock_token)
885
self._lock_token = token
887
self._lock_token = self._remote_lock_write(token)
888
# if self._lock_token is None, then this is something like packs or
889
# svn where we don't get to lock the repo, or a weave style repository
890
# where we cannot lock it over the wire and attempts to do so will
892
if self._real_repository is not None:
893
self._real_repository.lock_write(token=self._lock_token)
894
if token is not None:
895
self._leave_lock = True
897
self._leave_lock = False
898
self._lock_mode = 'w'
900
self._unstacked_provider.enable_cache(cache_misses=False)
901
elif self._lock_mode == 'r':
902
raise errors.ReadOnlyError(self)
904
self._lock_count += 1
905
for repo in self._fallback_repositories:
906
# Writes don't affect fallback repos
908
return self._lock_token or None
910
def leave_lock_in_place(self):
911
if not self._lock_token:
912
raise NotImplementedError(self.leave_lock_in_place)
913
self._leave_lock = True
915
def dont_leave_lock_in_place(self):
916
if not self._lock_token:
917
raise NotImplementedError(self.dont_leave_lock_in_place)
918
self._leave_lock = False
920
def _set_real_repository(self, repository):
921
"""Set the _real_repository for this repository.
923
:param repository: The repository to fallback to for non-hpss
924
implemented operations.
926
if self._real_repository is not None:
927
# Replacing an already set real repository.
928
# We cannot do this [currently] if the repository is locked -
929
# synchronised state might be lost.
931
raise AssertionError('_real_repository is already set')
932
if isinstance(repository, RemoteRepository):
933
raise AssertionError()
934
self._real_repository = repository
935
# three code paths happen here:
936
# 1) old servers, RemoteBranch.open() calls _ensure_real before setting
937
# up stacking. In this case self._fallback_repositories is [], and the
938
# real repo is already setup. Preserve the real repo and
939
# RemoteRepository.add_fallback_repository will avoid adding
941
# 2) new servers, RemoteBranch.open() sets up stacking, and when
942
# ensure_real is triggered from a branch, the real repository to
943
# set already has a matching list with separate instances, but
944
# as they are also RemoteRepositories we don't worry about making the
945
# lists be identical.
946
# 3) new servers, RemoteRepository.ensure_real is triggered before
947
# RemoteBranch.ensure real, in this case we get a repo with no fallbacks
948
# and need to populate it.
949
if (self._fallback_repositories and
950
len(self._real_repository._fallback_repositories) !=
951
len(self._fallback_repositories)):
952
if len(self._real_repository._fallback_repositories):
953
raise AssertionError(
954
"cannot cleanly remove existing _fallback_repositories")
955
for fb in self._fallback_repositories:
956
self._real_repository.add_fallback_repository(fb)
957
if self._lock_mode == 'w':
958
# if we are already locked, the real repository must be able to
959
# acquire the lock with our token.
960
self._real_repository.lock_write(self._lock_token)
961
elif self._lock_mode == 'r':
962
self._real_repository.lock_read()
964
def start_write_group(self):
965
"""Start a write group on the decorated repository.
967
Smart methods perform operations in a single step so this API
968
is not really applicable except as a compatibility thunk
969
for older plugins that don't use e.g. the CommitBuilder
973
return self._real_repository.start_write_group()
975
def _unlock(self, token):
976
path = self.bzrdir._path_for_remote_call(self._client)
978
# with no token the remote repository is not persistently locked.
980
err_context = {'token': token}
981
response = self._call('Repository.unlock', path, token,
983
if response == ('ok',):
986
raise errors.UnexpectedSmartServerResponse(response)
989
if not self._lock_count:
990
raise errors.LockNotHeld(self)
991
self._lock_count -= 1
992
if self._lock_count > 0:
994
self._unstacked_provider.disable_cache()
995
old_mode = self._lock_mode
996
self._lock_mode = None
998
# The real repository is responsible at present for raising an
999
# exception if it's in an unfinished write group. However, it
1000
# normally will *not* actually remove the lock from disk - that's
1001
# done by the server on receiving the Repository.unlock call.
1002
# This is just to let the _real_repository stay up to date.
1003
if self._real_repository is not None:
1004
self._real_repository.unlock()
1006
# The rpc-level lock should be released even if there was a
1007
# problem releasing the vfs-based lock.
1009
# Only write-locked repositories need to make a remote method
1010
# call to perform the unlock.
1011
old_token = self._lock_token
1012
self._lock_token = None
1013
if not self._leave_lock:
1014
self._unlock(old_token)
1016
def break_lock(self):
1017
# should hand off to the network
1019
return self._real_repository.break_lock()
1021
def _get_tarball(self, compression):
1022
"""Return a TemporaryFile containing a repository tarball.
1024
Returns None if the server does not support sending tarballs.
1027
path = self.bzrdir._path_for_remote_call(self._client)
1029
response, protocol = self._call_expecting_body(
1030
'Repository.tarball', path, compression)
1031
except errors.UnknownSmartMethod:
1032
protocol.cancel_read_body()
1034
if response[0] == 'ok':
1035
# Extract the tarball and return it
1036
t = tempfile.NamedTemporaryFile()
1037
# TODO: rpc layer should read directly into it...
1038
t.write(protocol.read_body_bytes())
1041
raise errors.UnexpectedSmartServerResponse(response)
1043
def sprout(self, to_bzrdir, revision_id=None):
1044
# TODO: Option to control what format is created?
1046
dest_repo = self._real_repository._format.initialize(to_bzrdir,
1048
dest_repo.fetch(self, revision_id=revision_id)
1051
### These methods are just thin shims to the VFS object for now.
1053
def revision_tree(self, revision_id):
1055
return self._real_repository.revision_tree(revision_id)
1057
def get_serializer_format(self):
1059
return self._real_repository.get_serializer_format()
1061
def get_commit_builder(self, branch, parents, config, timestamp=None,
1062
timezone=None, committer=None, revprops=None,
1064
# FIXME: It ought to be possible to call this without immediately
1065
# triggering _ensure_real. For now it's the easiest thing to do.
1067
real_repo = self._real_repository
1068
builder = real_repo.get_commit_builder(branch, parents,
1069
config, timestamp=timestamp, timezone=timezone,
1070
committer=committer, revprops=revprops, revision_id=revision_id)
1073
def add_fallback_repository(self, repository):
1074
"""Add a repository to use for looking up data not held locally.
1076
:param repository: A repository.
1078
if not self._format.supports_external_lookups:
1079
raise errors.UnstackableRepositoryFormat(
1080
self._format.network_name(), self.base)
1081
# We need to accumulate additional repositories here, to pass them in
1084
self._fallback_repositories.append(repository)
1085
# If self._real_repository was parameterised already (e.g. because a
1086
# _real_branch had its get_stacked_on_url method called), then the
1087
# repository to be added may already be in the _real_repositories list.
1088
if self._real_repository is not None:
1089
fallback_locations = [repo.bzrdir.root_transport.base for repo in
1090
self._real_repository._fallback_repositories]
1091
if repository.bzrdir.root_transport.base not in fallback_locations:
1092
self._real_repository.add_fallback_repository(repository)
1094
def add_inventory(self, revid, inv, parents):
1096
return self._real_repository.add_inventory(revid, inv, parents)
1098
def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1101
return self._real_repository.add_inventory_by_delta(basis_revision_id,
1102
delta, new_revision_id, parents)
1104
def add_revision(self, rev_id, rev, inv=None, config=None):
1106
return self._real_repository.add_revision(
1107
rev_id, rev, inv=inv, config=config)
1110
def get_inventory(self, revision_id):
1112
return self._real_repository.get_inventory(revision_id)
1114
def iter_inventories(self, revision_ids):
1116
return self._real_repository.iter_inventories(revision_ids)
1119
def get_revision(self, revision_id):
1121
return self._real_repository.get_revision(revision_id)
1123
def get_transaction(self):
1125
return self._real_repository.get_transaction()
1128
def clone(self, a_bzrdir, revision_id=None):
1130
return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
1132
def make_working_trees(self):
1133
"""See Repository.make_working_trees"""
1135
return self._real_repository.make_working_trees()
1137
def refresh_data(self):
1138
"""Re-read any data needed to to synchronise with disk.
1140
This method is intended to be called after another repository instance
1141
(such as one used by a smart server) has inserted data into the
1142
repository. It may not be called during a write group, but may be
1143
called at any other time.
1145
if self.is_in_write_group():
1146
raise errors.InternalBzrError(
1147
"May not refresh_data while in a write group.")
1148
if self._real_repository is not None:
1149
self._real_repository.refresh_data()
1151
def revision_ids_to_search_result(self, result_set):
1152
"""Convert a set of revision ids to a graph SearchResult."""
1153
result_parents = set()
1154
for parents in self.get_graph().get_parent_map(
1155
result_set).itervalues():
1156
result_parents.update(parents)
1157
included_keys = result_set.intersection(result_parents)
1158
start_keys = result_set.difference(included_keys)
1159
exclude_keys = result_parents.difference(result_set)
1160
result = graph.SearchResult(start_keys, exclude_keys,
1161
len(result_set), result_set)
1165
def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1166
"""Return the revision ids that other has that this does not.
1168
These are returned in topological order.
1170
revision_id: only return revision ids included by revision_id.
1172
return repository.InterRepository.get(
1173
other, self).search_missing_revision_ids(revision_id, find_ghosts)
1175
def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
1177
# No base implementation to use as RemoteRepository is not a subclass
1178
# of Repository; so this is a copy of Repository.fetch().
1179
if fetch_spec is not None and revision_id is not None:
1180
raise AssertionError(
1181
"fetch_spec and revision_id are mutually exclusive.")
1182
if self.is_in_write_group():
1183
raise errors.InternalBzrError(
1184
"May not fetch while in a write group.")
1185
# fast path same-url fetch operations
1186
if self.has_same_location(source) and fetch_spec is None:
1187
# check that last_revision is in 'from' and then return a
1189
if (revision_id is not None and
1190
not revision.is_null(revision_id)):
1191
self.get_revision(revision_id)
1193
# if there is no specific appropriate InterRepository, this will get
1194
# the InterRepository base class, which raises an
1195
# IncompatibleRepositories when asked to fetch.
1196
inter = repository.InterRepository.get(source, self)
1197
return inter.fetch(revision_id=revision_id, pb=pb,
1198
find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1200
def create_bundle(self, target, base, fileobj, format=None):
1202
self._real_repository.create_bundle(target, base, fileobj, format)
1205
def get_ancestry(self, revision_id, topo_sorted=True):
1207
return self._real_repository.get_ancestry(revision_id, topo_sorted)
1209
def fileids_altered_by_revision_ids(self, revision_ids):
1211
return self._real_repository.fileids_altered_by_revision_ids(revision_ids)
1213
def _get_versioned_file_checker(self, revisions, revision_versions_cache):
1215
return self._real_repository._get_versioned_file_checker(
1216
revisions, revision_versions_cache)
1218
def iter_files_bytes(self, desired_files):
1219
"""See Repository.iter_file_bytes.
1222
return self._real_repository.iter_files_bytes(desired_files)
1224
def get_parent_map(self, revision_ids):
1225
"""See bzrlib.Graph.get_parent_map()."""
1226
return self._make_parents_provider().get_parent_map(revision_ids)
1228
def _get_parent_map_rpc(self, keys):
1229
"""Helper for get_parent_map that performs the RPC."""
1230
medium = self._client._medium
1231
if medium._is_remote_before((1, 2)):
1232
# We already found out that the server can't understand
1233
# Repository.get_parent_map requests, so just fetch the whole
1236
# Note that this reads the whole graph, when only some keys are
1237
# wanted. On this old server there's no way (?) to get them all
1238
# in one go, and the user probably will have seen a warning about
1239
# the server being old anyhow.
1240
rg = self._get_revision_graph(None)
1241
# There is an API discrepancy between get_parent_map and
1242
# get_revision_graph. Specifically, a "key:()" pair in
1243
# get_revision_graph just means a node has no parents. For
1244
# "get_parent_map" it means the node is a ghost. So fix up the
1245
# graph to correct this.
1246
# https://bugs.launchpad.net/bzr/+bug/214894
1247
# There is one other "bug" which is that ghosts in
1248
# get_revision_graph() are not returned at all. But we won't worry
1249
# about that for now.
1250
for node_id, parent_ids in rg.iteritems():
1251
if parent_ids == ():
1252
rg[node_id] = (NULL_REVISION,)
1253
rg[NULL_REVISION] = ()
1258
raise ValueError('get_parent_map(None) is not valid')
1259
if NULL_REVISION in keys:
1260
keys.discard(NULL_REVISION)
1261
found_parents = {NULL_REVISION:()}
1263
return found_parents
1266
# TODO(Needs analysis): We could assume that the keys being requested
1267
# from get_parent_map are in a breadth first search, so typically they
1268
# will all be depth N from some common parent, and we don't have to
1269
# have the server iterate from the root parent, but rather from the
1270
# keys we're searching; and just tell the server the keyspace we
1271
# already have; but this may be more traffic again.
1273
# Transform self._parents_map into a search request recipe.
1274
# TODO: Manage this incrementally to avoid covering the same path
1275
# repeatedly. (The server will have to on each request, but the less
1276
# work done the better).
1278
# Negative caching notes:
1279
# new server sends missing when a request including the revid
1280
# 'include-missing:' is present in the request.
1281
# missing keys are serialised as missing:X, and we then call
1282
# provider.note_missing(X) for-all X
1283
parents_map = self._unstacked_provider.get_cached_map()
1284
if parents_map is None:
1285
# Repository is not locked, so there's no cache.
1287
# start_set is all the keys in the cache
1288
start_set = set(parents_map)
1289
# result set is all the references to keys in the cache
1290
result_parents = set()
1291
for parents in parents_map.itervalues():
1292
result_parents.update(parents)
1293
stop_keys = result_parents.difference(start_set)
1294
# We don't need to send ghosts back to the server as a position to
1296
stop_keys.difference_update(self._unstacked_provider.missing_keys)
1297
key_count = len(parents_map)
1298
if (NULL_REVISION in result_parents
1299
and NULL_REVISION in self._unstacked_provider.missing_keys):
1300
# If we pruned NULL_REVISION from the stop_keys because it's also
1301
# in our cache of "missing" keys we need to increment our key count
1302
# by 1, because the reconsitituted SearchResult on the server will
1303
# still consider NULL_REVISION to be an included key.
1305
included_keys = start_set.intersection(result_parents)
1306
start_set.difference_update(included_keys)
1307
recipe = ('manual', start_set, stop_keys, key_count)
1308
body = self._serialise_search_recipe(recipe)
1309
path = self.bzrdir._path_for_remote_call(self._client)
1311
if type(key) is not str:
1313
"key %r not a plain string" % (key,))
1314
verb = 'Repository.get_parent_map'
1315
args = (path, 'include-missing:') + tuple(keys)
1317
response = self._call_with_body_bytes_expecting_body(
1319
except errors.UnknownSmartMethod:
1320
# Server does not support this method, so get the whole graph.
1321
# Worse, we have to force a disconnection, because the server now
1322
# doesn't realise it has a body on the wire to consume, so the
1323
# only way to recover is to abandon the connection.
1325
'Server is too old for fast get_parent_map, reconnecting. '
1326
'(Upgrade the server to Bazaar 1.2 to avoid this)')
1328
# To avoid having to disconnect repeatedly, we keep track of the
1329
# fact the server doesn't understand remote methods added in 1.2.
1330
medium._remember_remote_is_before((1, 2))
1331
# Recurse just once and we should use the fallback code.
1332
return self._get_parent_map_rpc(keys)
1333
response_tuple, response_handler = response
1334
if response_tuple[0] not in ['ok']:
1335
response_handler.cancel_read_body()
1336
raise errors.UnexpectedSmartServerResponse(response_tuple)
1337
if response_tuple[0] == 'ok':
1338
coded = bz2.decompress(response_handler.read_body_bytes())
1340
# no revisions found
1342
lines = coded.split('\n')
1345
d = tuple(line.split())
1347
revision_graph[d[0]] = d[1:]
1350
if d[0].startswith('missing:'):
1352
self._unstacked_provider.note_missing_key(revid)
1354
# no parents - so give the Graph result
1356
revision_graph[d[0]] = (NULL_REVISION,)
1357
return revision_graph
1360
def get_signature_text(self, revision_id):
1362
return self._real_repository.get_signature_text(revision_id)
1365
def get_inventory_xml(self, revision_id):
1367
return self._real_repository.get_inventory_xml(revision_id)
1369
def deserialise_inventory(self, revision_id, xml):
1371
return self._real_repository.deserialise_inventory(revision_id, xml)
1373
def reconcile(self, other=None, thorough=False):
1375
return self._real_repository.reconcile(other=other, thorough=thorough)
1377
def all_revision_ids(self):
1379
return self._real_repository.all_revision_ids()
1382
def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1384
return self._real_repository.get_deltas_for_revisions(revisions,
1385
specific_fileids=specific_fileids)
1388
def get_revision_delta(self, revision_id, specific_fileids=None):
1390
return self._real_repository.get_revision_delta(revision_id,
1391
specific_fileids=specific_fileids)
1394
def revision_trees(self, revision_ids):
1396
return self._real_repository.revision_trees(revision_ids)
1399
def get_revision_reconcile(self, revision_id):
1401
return self._real_repository.get_revision_reconcile(revision_id)
1404
def check(self, revision_ids=None):
1406
return self._real_repository.check(revision_ids=revision_ids)
1408
def copy_content_into(self, destination, revision_id=None):
1410
return self._real_repository.copy_content_into(
1411
destination, revision_id=revision_id)
1413
def _copy_repository_tarball(self, to_bzrdir, revision_id=None):
1414
# get a tarball of the remote repository, and copy from that into the
1416
from bzrlib import osutils
1418
# TODO: Maybe a progress bar while streaming the tarball?
1419
note("Copying repository content as tarball...")
1420
tar_file = self._get_tarball('bz2')
1421
if tar_file is None:
1423
destination = to_bzrdir.create_repository()
1425
tar = tarfile.open('repository', fileobj=tar_file,
1427
tmpdir = osutils.mkdtemp()
1429
_extract_tar(tar, tmpdir)
1430
tmp_bzrdir = BzrDir.open(tmpdir)
1431
tmp_repo = tmp_bzrdir.open_repository()
1432
tmp_repo.copy_content_into(destination, revision_id)
1434
osutils.rmtree(tmpdir)
1438
# TODO: Suggestion from john: using external tar is much faster than
1439
# python's tarfile library, but it may not work on windows.
1442
def inventories(self):
1443
"""Decorate the real repository for now.
1445
In the long term a full blown network facility is needed to
1446
avoid creating a real repository object locally.
1449
return self._real_repository.inventories
1453
"""Compress the data within the repository.
1455
This is not currently implemented within the smart server.
1458
return self._real_repository.pack()
1461
def revisions(self):
1462
"""Decorate the real repository for now.
1464
In the short term this should become a real object to intercept graph
1467
In the long term a full blown network facility is needed.
1470
return self._real_repository.revisions
1472
def set_make_working_trees(self, new_value):
1474
new_value_str = "True"
1476
new_value_str = "False"
1477
path = self.bzrdir._path_for_remote_call(self._client)
1479
response = self._call(
1480
'Repository.set_make_working_trees', path, new_value_str)
1481
except errors.UnknownSmartMethod:
1483
self._real_repository.set_make_working_trees(new_value)
1485
if response[0] != 'ok':
1486
raise errors.UnexpectedSmartServerResponse(response)
1489
def signatures(self):
1490
"""Decorate the real repository for now.
1492
In the long term a full blown network facility is needed to avoid
1493
creating a real repository object locally.
1496
return self._real_repository.signatures
1499
def sign_revision(self, revision_id, gpg_strategy):
1501
return self._real_repository.sign_revision(revision_id, gpg_strategy)
1505
"""Decorate the real repository for now.
1507
In the long term a full blown network facility is needed to avoid
1508
creating a real repository object locally.
1511
return self._real_repository.texts
1514
def get_revisions(self, revision_ids):
1516
return self._real_repository.get_revisions(revision_ids)
1518
def supports_rich_root(self):
1519
return self._format.rich_root_data
1521
def iter_reverse_revision_history(self, revision_id):
1523
return self._real_repository.iter_reverse_revision_history(revision_id)
1526
def _serializer(self):
1527
return self._format._serializer
1529
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1531
return self._real_repository.store_revision_signature(
1532
gpg_strategy, plaintext, revision_id)
1534
def add_signature_text(self, revision_id, signature):
1536
return self._real_repository.add_signature_text(revision_id, signature)
1538
def has_signature_for_revision_id(self, revision_id):
1540
return self._real_repository.has_signature_for_revision_id(revision_id)
1542
def item_keys_introduced_by(self, revision_ids, _files_pb=None):
1544
return self._real_repository.item_keys_introduced_by(revision_ids,
1545
_files_pb=_files_pb)
1547
def revision_graph_can_have_wrong_parents(self):
1548
# The answer depends on the remote repo format.
1550
return self._real_repository.revision_graph_can_have_wrong_parents()
1552
def _find_inconsistent_revision_parents(self):
1554
return self._real_repository._find_inconsistent_revision_parents()
1556
def _check_for_inconsistent_revision_parents(self):
1558
return self._real_repository._check_for_inconsistent_revision_parents()
1560
def _make_parents_provider(self, other=None):
1561
providers = [self._unstacked_provider]
1562
if other is not None:
1563
providers.insert(0, other)
1564
providers.extend(r._make_parents_provider() for r in
1565
self._fallback_repositories)
1566
return graph._StackedParentsProvider(providers)
1568
def _serialise_search_recipe(self, recipe):
1569
"""Serialise a graph search recipe.
1571
:param recipe: A search recipe (start, stop, count).
1572
:return: Serialised bytes.
1574
start_keys = ' '.join(recipe[1])
1575
stop_keys = ' '.join(recipe[2])
1576
count = str(recipe[3])
1577
return '\n'.join((start_keys, stop_keys, count))
1579
def _serialise_search_result(self, search_result):
1580
if isinstance(search_result, graph.PendingAncestryResult):
1581
parts = ['ancestry-of']
1582
parts.extend(search_result.heads)
1584
recipe = search_result.get_recipe()
1585
parts = [recipe[0], self._serialise_search_recipe(recipe)]
1586
return '\n'.join(parts)
1589
path = self.bzrdir._path_for_remote_call(self._client)
1591
response = self._call('PackRepository.autopack', path)
1592
except errors.UnknownSmartMethod:
1594
self._real_repository._pack_collection.autopack()
1597
if response[0] != 'ok':
1598
raise errors.UnexpectedSmartServerResponse(response)
1601
class RemoteStreamSink(repository.StreamSink):
1603
def _insert_real(self, stream, src_format, resume_tokens):
1604
self.target_repo._ensure_real()
1605
sink = self.target_repo._real_repository._get_sink()
1606
result = sink.insert_stream(stream, src_format, resume_tokens)
1608
self.target_repo.autopack()
1611
def insert_stream(self, stream, src_format, resume_tokens):
1612
target = self.target_repo
1613
if target._lock_token:
1614
verb = 'Repository.insert_stream_locked'
1615
extra_args = (target._lock_token or '',)
1616
required_version = (1, 14)
1618
verb = 'Repository.insert_stream'
1620
required_version = (1, 13)
1621
client = target._client
1622
medium = client._medium
1623
if medium._is_remote_before(required_version):
1624
# No possible way this can work.
1625
return self._insert_real(stream, src_format, resume_tokens)
1626
path = target.bzrdir._path_for_remote_call(client)
1627
if not resume_tokens:
1628
# XXX: Ugly but important for correctness, *will* be fixed during
1629
# 1.13 cycle. Pushing a stream that is interrupted results in a
1630
# fallback to the _real_repositories sink *with a partial stream*.
1631
# Thats bad because we insert less data than bzr expected. To avoid
1632
# this we do a trial push to make sure the verb is accessible, and
1633
# do not fallback when actually pushing the stream. A cleanup patch
1634
# is going to look at rewinding/restarting the stream/partial
1636
byte_stream = smart_repo._stream_to_byte_stream([], src_format)
1638
response = client.call_with_body_stream(
1639
(verb, path, '') + extra_args, byte_stream)
1640
except errors.UnknownSmartMethod:
1641
medium._remember_remote_is_before(required_version)
1642
return self._insert_real(stream, src_format, resume_tokens)
1643
byte_stream = smart_repo._stream_to_byte_stream(
1645
resume_tokens = ' '.join(resume_tokens)
1646
response = client.call_with_body_stream(
1647
(verb, path, resume_tokens) + extra_args, byte_stream)
1648
if response[0][0] not in ('ok', 'missing-basis'):
1649
raise errors.UnexpectedSmartServerResponse(response)
1650
if response[0][0] == 'missing-basis':
1651
tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1652
resume_tokens = tokens
1653
return resume_tokens, set(missing_keys)
1655
self.target_repo.refresh_data()
1659
class RemoteStreamSource(repository.StreamSource):
1660
"""Stream data from a remote server."""
1662
def get_stream(self, search):
1663
if (self.from_repository._fallback_repositories and
1664
self.to_format._fetch_order == 'topological'):
1665
return self._real_stream(self.from_repository, search)
1666
return self.missing_parents_chain(search, [self.from_repository] +
1667
self.from_repository._fallback_repositories)
1669
def _real_stream(self, repo, search):
1670
"""Get a stream for search from repo.
1672
This never called RemoteStreamSource.get_stream, and is a heler
1673
for RemoteStreamSource._get_stream to allow getting a stream
1674
reliably whether fallback back because of old servers or trying
1675
to stream from a non-RemoteRepository (which the stacked support
1678
source = repo._get_source(self.to_format)
1679
if isinstance(source, RemoteStreamSource):
1680
return repository.StreamSource.get_stream(source, search)
1681
return source.get_stream(search)
1683
def _get_stream(self, repo, search):
1684
"""Core worker to get a stream from repo for search.
1686
This is used by both get_stream and the stacking support logic. It
1687
deliberately gets a stream for repo which does not need to be
1688
self.from_repository. In the event that repo is not Remote, or
1689
cannot do a smart stream, a fallback is made to the generic
1690
repository._get_stream() interface, via self._real_stream.
1692
In the event of stacking, streams from _get_stream will not
1693
contain all the data for search - this is normal (see get_stream).
1695
:param repo: A repository.
1696
:param search: A search.
1698
# Fallbacks may be non-smart
1699
if not isinstance(repo, RemoteRepository):
1700
return self._real_stream(repo, search)
1701
client = repo._client
1702
medium = client._medium
1703
if medium._is_remote_before((1, 13)):
1704
# streaming was added in 1.13
1705
return self._real_stream(repo, search)
1706
path = repo.bzrdir._path_for_remote_call(client)
1708
search_bytes = repo._serialise_search_result(search)
1709
response = repo._call_with_body_bytes_expecting_body(
1710
'Repository.get_stream',
1711
(path, self.to_format.network_name()), search_bytes)
1712
response_tuple, response_handler = response
1713
except errors.UnknownSmartMethod:
1714
medium._remember_remote_is_before((1,13))
1715
return self._real_stream(repo, search)
1716
if response_tuple[0] != 'ok':
1717
raise errors.UnexpectedSmartServerResponse(response_tuple)
1718
byte_stream = response_handler.read_streamed_body()
1719
src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
1720
if src_format.network_name() != repo._format.network_name():
1721
raise AssertionError(
1722
"Mismatched RemoteRepository and stream src %r, %r" % (
1723
src_format.network_name(), repo._format.network_name()))
1726
def missing_parents_chain(self, search, sources):
1727
"""Chain multiple streams together to handle stacking.
1729
:param search: The overall search to satisfy with streams.
1730
:param sources: A list of Repository objects to query.
1732
self.serialiser = self.to_format._serializer
1733
self.seen_revs = set()
1734
self.referenced_revs = set()
1735
# If there are heads in the search, or the key count is > 0, we are not
1737
while not search.is_empty() and len(sources) > 1:
1738
source = sources.pop(0)
1739
stream = self._get_stream(source, search)
1740
for kind, substream in stream:
1741
if kind != 'revisions':
1742
yield kind, substream
1744
yield kind, self.missing_parents_rev_handler(substream)
1745
search = search.refine(self.seen_revs, self.referenced_revs)
1746
self.seen_revs = set()
1747
self.referenced_revs = set()
1748
if not search.is_empty():
1749
for kind, stream in self._get_stream(sources[0], search):
1752
def missing_parents_rev_handler(self, substream):
1753
for content in substream:
1754
revision_bytes = content.get_bytes_as('fulltext')
1755
revision = self.serialiser.read_revision_from_string(revision_bytes)
1756
self.seen_revs.add(content.key[-1])
1757
self.referenced_revs.update(revision.parent_ids)
1761
class RemoteBranchLockableFiles(LockableFiles):
1762
"""A 'LockableFiles' implementation that talks to a smart server.
1764
This is not a public interface class.
1767
def __init__(self, bzrdir, _client):
1768
self.bzrdir = bzrdir
1769
self._client = _client
1770
self._need_find_modes = True
1771
LockableFiles.__init__(
1772
self, bzrdir.get_branch_transport(None),
1773
'lock', lockdir.LockDir)
1775
def _find_modes(self):
1776
# RemoteBranches don't let the client set the mode of control files.
1777
self._dir_mode = None
1778
self._file_mode = None
1781
class RemoteBranchFormat(branch.BranchFormat):
1783
def __init__(self, network_name=None):
1784
super(RemoteBranchFormat, self).__init__()
1785
self._matchingbzrdir = RemoteBzrDirFormat()
1786
self._matchingbzrdir.set_branch_format(self)
1787
self._custom_format = None
1788
self._network_name = network_name
1790
def __eq__(self, other):
1791
return (isinstance(other, RemoteBranchFormat) and
1792
self.__dict__ == other.__dict__)
1794
def _ensure_real(self):
1795
if self._custom_format is None:
1796
self._custom_format = branch.network_format_registry.get(
1799
def get_format_description(self):
1800
return 'Remote BZR Branch'
1802
def network_name(self):
1803
return self._network_name
1805
def open(self, a_bzrdir, ignore_fallbacks=False):
1806
return a_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
1808
def _vfs_initialize(self, a_bzrdir):
1809
# Initialisation when using a local bzrdir object, or a non-vfs init
1810
# method is not available on the server.
1811
# self._custom_format is always set - the start of initialize ensures
1813
if isinstance(a_bzrdir, RemoteBzrDir):
1814
a_bzrdir._ensure_real()
1815
result = self._custom_format.initialize(a_bzrdir._real_bzrdir)
1817
# We assume the bzrdir is parameterised; it may not be.
1818
result = self._custom_format.initialize(a_bzrdir)
1819
if (isinstance(a_bzrdir, RemoteBzrDir) and
1820
not isinstance(result, RemoteBranch)):
1821
result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result)
1824
def initialize(self, a_bzrdir):
1825
# 1) get the network name to use.
1826
if self._custom_format:
1827
network_name = self._custom_format.network_name()
1829
# Select the current bzrlib default and ask for that.
1830
reference_bzrdir_format = bzrdir.format_registry.get('default')()
1831
reference_format = reference_bzrdir_format.get_branch_format()
1832
self._custom_format = reference_format
1833
network_name = reference_format.network_name()
1834
# Being asked to create on a non RemoteBzrDir:
1835
if not isinstance(a_bzrdir, RemoteBzrDir):
1836
return self._vfs_initialize(a_bzrdir)
1837
medium = a_bzrdir._client._medium
1838
if medium._is_remote_before((1, 13)):
1839
return self._vfs_initialize(a_bzrdir)
1840
# Creating on a remote bzr dir.
1841
# 2) try direct creation via RPC
1842
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
1843
verb = 'BzrDir.create_branch'
1845
response = a_bzrdir._call(verb, path, network_name)
1846
except errors.UnknownSmartMethod:
1847
# Fallback - use vfs methods
1848
medium._remember_remote_is_before((1, 13))
1849
return self._vfs_initialize(a_bzrdir)
1850
if response[0] != 'ok':
1851
raise errors.UnexpectedSmartServerResponse(response)
1852
# Turn the response into a RemoteRepository object.
1853
format = RemoteBranchFormat(network_name=response[1])
1854
repo_format = response_tuple_to_repo_format(response[3:])
1855
if response[2] == '':
1856
repo_bzrdir = a_bzrdir
1858
repo_bzrdir = RemoteBzrDir(
1859
a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
1861
remote_repo = RemoteRepository(repo_bzrdir, repo_format)
1862
remote_branch = RemoteBranch(a_bzrdir, remote_repo,
1863
format=format, setup_stacking=False)
1864
# XXX: We know this is a new branch, so it must have revno 0, revid
1865
# NULL_REVISION. Creating the branch locked would make this be unable
1866
# to be wrong; here its simply very unlikely to be wrong. RBC 20090225
1867
remote_branch._last_revision_info_cache = 0, NULL_REVISION
1868
return remote_branch
1870
def make_tags(self, branch):
1872
return self._custom_format.make_tags(branch)
1874
def supports_tags(self):
1875
# Remote branches might support tags, but we won't know until we
1876
# access the real remote branch.
1878
return self._custom_format.supports_tags()
1880
def supports_stacking(self):
1882
return self._custom_format.supports_stacking()
1885
class RemoteBranch(branch.Branch, _RpcHelper):
1886
"""Branch stored on a server accessed by HPSS RPC.
1888
At the moment most operations are mapped down to simple file operations.
1891
def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
1892
_client=None, format=None, setup_stacking=True):
1893
"""Create a RemoteBranch instance.
1895
:param real_branch: An optional local implementation of the branch
1896
format, usually accessing the data via the VFS.
1897
:param _client: Private parameter for testing.
1898
:param format: A RemoteBranchFormat object, None to create one
1899
automatically. If supplied it should have a network_name already
1901
:param setup_stacking: If True make an RPC call to determine the
1902
stacked (or not) status of the branch. If False assume the branch
1905
# We intentionally don't call the parent class's __init__, because it
1906
# will try to assign to self.tags, which is a property in this subclass.
1907
# And the parent's __init__ doesn't do much anyway.
1908
self._revision_id_to_revno_cache = None
1909
self._partial_revision_id_to_revno_cache = {}
1910
self._revision_history_cache = None
1911
self._last_revision_info_cache = None
1912
self._merge_sorted_revisions_cache = None
1913
self.bzrdir = remote_bzrdir
1914
if _client is not None:
1915
self._client = _client
1917
self._client = remote_bzrdir._client
1918
self.repository = remote_repository
1919
if real_branch is not None:
1920
self._real_branch = real_branch
1921
# Give the remote repository the matching real repo.
1922
real_repo = self._real_branch.repository
1923
if isinstance(real_repo, RemoteRepository):
1924
real_repo._ensure_real()
1925
real_repo = real_repo._real_repository
1926
self.repository._set_real_repository(real_repo)
1927
# Give the branch the remote repository to let fast-pathing happen.
1928
self._real_branch.repository = self.repository
1930
self._real_branch = None
1931
# Fill out expected attributes of branch for bzrlib API users.
1932
self.base = self.bzrdir.root_transport.base
1933
self._control_files = None
1934
self._lock_mode = None
1935
self._lock_token = None
1936
self._repo_lock_token = None
1937
self._lock_count = 0
1938
self._leave_lock = False
1939
# Setup a format: note that we cannot call _ensure_real until all the
1940
# attributes above are set: This code cannot be moved higher up in this
1943
self._format = RemoteBranchFormat()
1944
if real_branch is not None:
1945
self._format._network_name = \
1946
self._real_branch._format.network_name()
1948
self._format = format
1949
if not self._format._network_name:
1950
# Did not get from open_branchV2 - old server.
1952
self._format._network_name = \
1953
self._real_branch._format.network_name()
1954
self.tags = self._format.make_tags(self)
1955
# The base class init is not called, so we duplicate this:
1956
hooks = branch.Branch.hooks['open']
1960
self._setup_stacking()
1962
def _setup_stacking(self):
1963
# configure stacking into the remote repository, by reading it from
1966
fallback_url = self.get_stacked_on_url()
1967
except (errors.NotStacked, errors.UnstackableBranchFormat,
1968
errors.UnstackableRepositoryFormat), e:
1970
self._activate_fallback_location(fallback_url, None)
1972
def _get_config(self):
1973
return RemoteBranchConfig(self)
1975
def _get_real_transport(self):
1976
# if we try vfs access, return the real branch's vfs transport
1978
return self._real_branch._transport
1980
_transport = property(_get_real_transport)
1983
return "%s(%s)" % (self.__class__.__name__, self.base)
1987
def _ensure_real(self):
1988
"""Ensure that there is a _real_branch set.
1990
Used before calls to self._real_branch.
1992
if self._real_branch is None:
1993
if not vfs.vfs_enabled():
1994
raise AssertionError('smart server vfs must be enabled '
1995
'to use vfs implementation')
1996
self.bzrdir._ensure_real()
1997
self._real_branch = self.bzrdir._real_bzrdir.open_branch()
1998
if self.repository._real_repository is None:
1999
# Give the remote repository the matching real repo.
2000
real_repo = self._real_branch.repository
2001
if isinstance(real_repo, RemoteRepository):
2002
real_repo._ensure_real()
2003
real_repo = real_repo._real_repository
2004
self.repository._set_real_repository(real_repo)
2005
# Give the real branch the remote repository to let fast-pathing
2007
self._real_branch.repository = self.repository
2008
if self._lock_mode == 'r':
2009
self._real_branch.lock_read()
2010
elif self._lock_mode == 'w':
2011
self._real_branch.lock_write(token=self._lock_token)
2013
def _translate_error(self, err, **context):
2014
self.repository._translate_error(err, branch=self, **context)
2016
def _clear_cached_state(self):
2017
super(RemoteBranch, self)._clear_cached_state()
2018
if self._real_branch is not None:
2019
self._real_branch._clear_cached_state()
2021
def _clear_cached_state_of_remote_branch_only(self):
2022
"""Like _clear_cached_state, but doesn't clear the cache of
2025
This is useful when falling back to calling a method of
2026
self._real_branch that changes state. In that case the underlying
2027
branch changes, so we need to invalidate this RemoteBranch's cache of
2028
it. However, there's no need to invalidate the _real_branch's cache
2029
too, in fact doing so might harm performance.
2031
super(RemoteBranch, self)._clear_cached_state()
2034
def control_files(self):
2035
# Defer actually creating RemoteBranchLockableFiles until its needed,
2036
# because it triggers an _ensure_real that we otherwise might not need.
2037
if self._control_files is None:
2038
self._control_files = RemoteBranchLockableFiles(
2039
self.bzrdir, self._client)
2040
return self._control_files
2042
def _get_checkout_format(self):
2044
return self._real_branch._get_checkout_format()
2046
def get_physical_lock_status(self):
2047
"""See Branch.get_physical_lock_status()."""
2048
# should be an API call to the server, as branches must be lockable.
2050
return self._real_branch.get_physical_lock_status()
2052
def get_stacked_on_url(self):
2053
"""Get the URL this branch is stacked against.
2055
:raises NotStacked: If the branch is not stacked.
2056
:raises UnstackableBranchFormat: If the branch does not support
2058
:raises UnstackableRepositoryFormat: If the repository does not support
2062
# there may not be a repository yet, so we can't use
2063
# self._translate_error, so we can't use self._call either.
2064
response = self._client.call('Branch.get_stacked_on_url',
2065
self._remote_path())
2066
except errors.ErrorFromSmartServer, err:
2067
# there may not be a repository yet, so we can't call through
2068
# its _translate_error
2069
_translate_error(err, branch=self)
2070
except errors.UnknownSmartMethod, err:
2072
return self._real_branch.get_stacked_on_url()
2073
if response[0] != 'ok':
2074
raise errors.UnexpectedSmartServerResponse(response)
2077
def _vfs_get_tags_bytes(self):
2079
return self._real_branch._get_tags_bytes()
2081
def _get_tags_bytes(self):
2082
medium = self._client._medium
2083
if medium._is_remote_before((1, 13)):
2084
return self._vfs_get_tags_bytes()
2086
response = self._call('Branch.get_tags_bytes', self._remote_path())
2087
except errors.UnknownSmartMethod:
2088
medium._remember_remote_is_before((1, 13))
2089
return self._vfs_get_tags_bytes()
2092
def lock_read(self):
2093
self.repository.lock_read()
2094
if not self._lock_mode:
2095
self._lock_mode = 'r'
2096
self._lock_count = 1
2097
if self._real_branch is not None:
2098
self._real_branch.lock_read()
2100
self._lock_count += 1
2102
def _remote_lock_write(self, token):
2104
branch_token = repo_token = ''
2106
branch_token = token
2107
repo_token = self.repository.lock_write()
2108
self.repository.unlock()
2109
err_context = {'token': token}
2110
response = self._call(
2111
'Branch.lock_write', self._remote_path(), branch_token,
2112
repo_token or '', **err_context)
2113
if response[0] != 'ok':
2114
raise errors.UnexpectedSmartServerResponse(response)
2115
ok, branch_token, repo_token = response
2116
return branch_token, repo_token
2118
def lock_write(self, token=None):
2119
if not self._lock_mode:
2120
# Lock the branch and repo in one remote call.
2121
remote_tokens = self._remote_lock_write(token)
2122
self._lock_token, self._repo_lock_token = remote_tokens
2123
if not self._lock_token:
2124
raise SmartProtocolError('Remote server did not return a token!')
2125
# Tell the self.repository object that it is locked.
2126
self.repository.lock_write(
2127
self._repo_lock_token, _skip_rpc=True)
2129
if self._real_branch is not None:
2130
self._real_branch.lock_write(token=self._lock_token)
2131
if token is not None:
2132
self._leave_lock = True
2134
self._leave_lock = False
2135
self._lock_mode = 'w'
2136
self._lock_count = 1
2137
elif self._lock_mode == 'r':
2138
raise errors.ReadOnlyTransaction
2140
if token is not None:
2141
# A token was given to lock_write, and we're relocking, so
2142
# check that the given token actually matches the one we
2144
if token != self._lock_token:
2145
raise errors.TokenMismatch(token, self._lock_token)
2146
self._lock_count += 1
2147
# Re-lock the repository too.
2148
self.repository.lock_write(self._repo_lock_token)
2149
return self._lock_token or None
2151
def _set_tags_bytes(self, bytes):
2153
return self._real_branch._set_tags_bytes(bytes)
2155
def _unlock(self, branch_token, repo_token):
2156
err_context = {'token': str((branch_token, repo_token))}
2157
response = self._call(
2158
'Branch.unlock', self._remote_path(), branch_token,
2159
repo_token or '', **err_context)
2160
if response == ('ok',):
2162
raise errors.UnexpectedSmartServerResponse(response)
2166
self._lock_count -= 1
2167
if not self._lock_count:
2168
self._clear_cached_state()
2169
mode = self._lock_mode
2170
self._lock_mode = None
2171
if self._real_branch is not None:
2172
if (not self._leave_lock and mode == 'w' and
2173
self._repo_lock_token):
2174
# If this RemoteBranch will remove the physical lock
2175
# for the repository, make sure the _real_branch
2176
# doesn't do it first. (Because the _real_branch's
2177
# repository is set to be the RemoteRepository.)
2178
self._real_branch.repository.leave_lock_in_place()
2179
self._real_branch.unlock()
2181
# Only write-locked branched need to make a remote method
2182
# call to perform the unlock.
2184
if not self._lock_token:
2185
raise AssertionError('Locked, but no token!')
2186
branch_token = self._lock_token
2187
repo_token = self._repo_lock_token
2188
self._lock_token = None
2189
self._repo_lock_token = None
2190
if not self._leave_lock:
2191
self._unlock(branch_token, repo_token)
2193
self.repository.unlock()
2195
def break_lock(self):
2197
return self._real_branch.break_lock()
2199
def leave_lock_in_place(self):
2200
if not self._lock_token:
2201
raise NotImplementedError(self.leave_lock_in_place)
2202
self._leave_lock = True
2204
def dont_leave_lock_in_place(self):
2205
if not self._lock_token:
2206
raise NotImplementedError(self.dont_leave_lock_in_place)
2207
self._leave_lock = False
2209
def _last_revision_info(self):
2210
response = self._call('Branch.last_revision_info', self._remote_path())
2211
if response[0] != 'ok':
2212
raise SmartProtocolError('unexpected response code %s' % (response,))
2213
revno = int(response[1])
2214
last_revision = response[2]
2215
return (revno, last_revision)
2217
def _gen_revision_history(self):
2218
"""See Branch._gen_revision_history()."""
2219
response_tuple, response_handler = self._call_expecting_body(
2220
'Branch.revision_history', self._remote_path())
2221
if response_tuple[0] != 'ok':
2222
raise errors.UnexpectedSmartServerResponse(response_tuple)
2223
result = response_handler.read_body_bytes().split('\x00')
2228
def _remote_path(self):
2229
return self.bzrdir._path_for_remote_call(self._client)
2231
def _set_last_revision_descendant(self, revision_id, other_branch,
2232
allow_diverged=False, allow_overwrite_descendant=False):
2233
# This performs additional work to meet the hook contract; while its
2234
# undesirable, we have to synthesise the revno to call the hook, and
2235
# not calling the hook is worse as it means changes can't be prevented.
2236
# Having calculated this though, we can't just call into
2237
# set_last_revision_info as a simple call, because there is a set_rh
2238
# hook that some folk may still be using.
2239
old_revno, old_revid = self.last_revision_info()
2240
history = self._lefthand_history(revision_id)
2241
self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2242
err_context = {'other_branch': other_branch}
2243
response = self._call('Branch.set_last_revision_ex',
2244
self._remote_path(), self._lock_token, self._repo_lock_token,
2245
revision_id, int(allow_diverged), int(allow_overwrite_descendant),
2247
self._clear_cached_state()
2248
if len(response) != 3 and response[0] != 'ok':
2249
raise errors.UnexpectedSmartServerResponse(response)
2250
new_revno, new_revision_id = response[1:]
2251
self._last_revision_info_cache = new_revno, new_revision_id
2252
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2253
if self._real_branch is not None:
2254
cache = new_revno, new_revision_id
2255
self._real_branch._last_revision_info_cache = cache
2257
def _set_last_revision(self, revision_id):
2258
old_revno, old_revid = self.last_revision_info()
2259
# This performs additional work to meet the hook contract; while its
2260
# undesirable, we have to synthesise the revno to call the hook, and
2261
# not calling the hook is worse as it means changes can't be prevented.
2262
# Having calculated this though, we can't just call into
2263
# set_last_revision_info as a simple call, because there is a set_rh
2264
# hook that some folk may still be using.
2265
history = self._lefthand_history(revision_id)
2266
self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2267
self._clear_cached_state()
2268
response = self._call('Branch.set_last_revision',
2269
self._remote_path(), self._lock_token, self._repo_lock_token,
2271
if response != ('ok',):
2272
raise errors.UnexpectedSmartServerResponse(response)
2273
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2276
def set_revision_history(self, rev_history):
2277
# Send just the tip revision of the history; the server will generate
2278
# the full history from that. If the revision doesn't exist in this
2279
# branch, NoSuchRevision will be raised.
2280
if rev_history == []:
2283
rev_id = rev_history[-1]
2284
self._set_last_revision(rev_id)
2285
for hook in branch.Branch.hooks['set_rh']:
2286
hook(self, rev_history)
2287
self._cache_revision_history(rev_history)
2289
def _get_parent_location(self):
2290
medium = self._client._medium
2291
if medium._is_remote_before((1, 13)):
2292
return self._vfs_get_parent_location()
2294
response = self._call('Branch.get_parent', self._remote_path())
2295
except errors.UnknownSmartMethod:
2296
medium._remember_remote_is_before((1, 13))
2297
return self._vfs_get_parent_location()
2298
if len(response) != 1:
2299
raise errors.UnexpectedSmartServerResponse(response)
2300
parent_location = response[0]
2301
if parent_location == '':
2303
return parent_location
2305
def _vfs_get_parent_location(self):
2307
return self._real_branch._get_parent_location()
2309
def _set_parent_location(self, url):
2310
medium = self._client._medium
2311
if medium._is_remote_before((1, 15)):
2312
return self._vfs_set_parent_location(url)
2314
call_url = url or ''
2315
if type(call_url) is not str:
2316
raise AssertionError('url must be a str or None (%s)' % url)
2317
response = self._call('Branch.set_parent_location',
2318
self._remote_path(), self._lock_token, self._repo_lock_token,
2320
except errors.UnknownSmartMethod:
2321
medium._remember_remote_is_before((1, 15))
2322
return self._vfs_set_parent_location(url)
2324
raise errors.UnexpectedSmartServerResponse(response)
2326
def _vfs_set_parent_location(self, url):
2328
return self._real_branch._set_parent_location(url)
2331
def pull(self, source, overwrite=False, stop_revision=None,
2333
self._clear_cached_state_of_remote_branch_only()
2335
return self._real_branch.pull(
2336
source, overwrite=overwrite, stop_revision=stop_revision,
2337
_override_hook_target=self, **kwargs)
2340
def push(self, target, overwrite=False, stop_revision=None):
2342
return self._real_branch.push(
2343
target, overwrite=overwrite, stop_revision=stop_revision,
2344
_override_hook_source_branch=self)
2346
def is_locked(self):
2347
return self._lock_count >= 1
2350
def revision_id_to_revno(self, revision_id):
2352
return self._real_branch.revision_id_to_revno(revision_id)
2355
def set_last_revision_info(self, revno, revision_id):
2356
# XXX: These should be returned by the set_last_revision_info verb
2357
old_revno, old_revid = self.last_revision_info()
2358
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2359
revision_id = ensure_null(revision_id)
2361
response = self._call('Branch.set_last_revision_info',
2362
self._remote_path(), self._lock_token, self._repo_lock_token,
2363
str(revno), revision_id)
2364
except errors.UnknownSmartMethod:
2366
self._clear_cached_state_of_remote_branch_only()
2367
self._real_branch.set_last_revision_info(revno, revision_id)
2368
self._last_revision_info_cache = revno, revision_id
2370
if response == ('ok',):
2371
self._clear_cached_state()
2372
self._last_revision_info_cache = revno, revision_id
2373
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2374
# Update the _real_branch's cache too.
2375
if self._real_branch is not None:
2376
cache = self._last_revision_info_cache
2377
self._real_branch._last_revision_info_cache = cache
2379
raise errors.UnexpectedSmartServerResponse(response)
2382
def generate_revision_history(self, revision_id, last_rev=None,
2384
medium = self._client._medium
2385
if not medium._is_remote_before((1, 6)):
2386
# Use a smart method for 1.6 and above servers
2388
self._set_last_revision_descendant(revision_id, other_branch,
2389
allow_diverged=True, allow_overwrite_descendant=True)
2391
except errors.UnknownSmartMethod:
2392
medium._remember_remote_is_before((1, 6))
2393
self._clear_cached_state_of_remote_branch_only()
2394
self.set_revision_history(self._lefthand_history(revision_id,
2395
last_rev=last_rev,other_branch=other_branch))
2397
def set_push_location(self, location):
2399
return self._real_branch.set_push_location(location)
2402
class RemoteConfig(object):
2403
"""A Config that reads and writes from smart verbs.
2405
It is a low-level object that considers config data to be name/value pairs
2406
that may be associated with a section. Assigning meaning to the these
2407
values is done at higher levels like bzrlib.config.TreeConfig.
2410
def get_option(self, name, section=None, default=None):
2411
"""Return the value associated with a named option.
2413
:param name: The name of the value
2414
:param section: The section the option is in (if any)
2415
:param default: The value to return if the value is not set
2416
:return: The value or default value
2419
configobj = self._get_configobj()
2421
section_obj = configobj
2424
section_obj = configobj[section]
2427
return section_obj.get(name, default)
2428
except errors.UnknownSmartMethod:
2429
return self._vfs_get_option(name, section, default)
2431
def _response_to_configobj(self, response):
2432
if len(response[0]) and response[0][0] != 'ok':
2433
raise errors.UnexpectedSmartServerResponse(response)
2434
lines = response[1].read_body_bytes().splitlines()
2435
return config.ConfigObj(lines, encoding='utf-8')
2438
class RemoteBranchConfig(RemoteConfig):
2439
"""A RemoteConfig for Branches."""
2441
def __init__(self, branch):
2442
self._branch = branch
2444
def _get_configobj(self):
2445
path = self._branch._remote_path()
2446
response = self._branch._client.call_expecting_body(
2447
'Branch.get_config_file', path)
2448
return self._response_to_configobj(response)
2450
def set_option(self, value, name, section=None):
2451
"""Set the value associated with a named option.
2453
:param value: The value to set
2454
:param name: The name of the value to set
2455
:param section: The section the option is in (if any)
2457
medium = self._branch._client._medium
2458
if medium._is_remote_before((1, 14)):
2459
return self._vfs_set_option(value, name, section)
2461
path = self._branch._remote_path()
2462
response = self._branch._client.call('Branch.set_config_option',
2463
path, self._branch._lock_token, self._branch._repo_lock_token,
2464
value.encode('utf8'), name, section or '')
2465
except errors.UnknownSmartMethod:
2466
medium._remember_remote_is_before((1, 14))
2467
return self._vfs_set_option(value, name, section)
2469
raise errors.UnexpectedSmartServerResponse(response)
2471
def _real_object(self):
2472
self._branch._ensure_real()
2473
return self._branch._real_branch
2475
def _vfs_set_option(self, value, name, section=None):
2476
return self._real_object()._get_config().set_option(
2477
value, name, section)
2480
class RemoteBzrDirConfig(RemoteConfig):
2481
"""A RemoteConfig for BzrDirs."""
2483
def __init__(self, bzrdir):
2484
self._bzrdir = bzrdir
2486
def _get_configobj(self):
2487
medium = self._bzrdir._client._medium
2488
verb = 'BzrDir.get_config_file'
2489
if medium._is_remote_before((1, 15)):
2490
raise errors.UnknownSmartMethod(verb)
2491
path = self._bzrdir._path_for_remote_call(self._bzrdir._client)
2492
response = self._bzrdir._call_expecting_body(
2494
return self._response_to_configobj(response)
2496
def _vfs_get_option(self, name, section, default):
2497
return self._real_object()._get_config().get_option(
2498
name, section, default)
2500
def set_option(self, value, name, section=None):
2501
"""Set the value associated with a named option.
2503
:param value: The value to set
2504
:param name: The name of the value to set
2505
:param section: The section the option is in (if any)
2507
return self._real_object()._get_config().set_option(
2508
value, name, section)
2510
def _real_object(self):
2511
self._bzrdir._ensure_real()
2512
return self._bzrdir._real_bzrdir
2516
def _extract_tar(tar, to_dir):
2517
"""Extract all the contents of a tarfile object.
2519
A replacement for extractall, which is not present in python2.4
2522
tar.extract(tarinfo, to_dir)
2525
def _translate_error(err, **context):
2526
"""Translate an ErrorFromSmartServer into a more useful error.
2528
Possible context keys:
2536
If the error from the server doesn't match a known pattern, then
2537
UnknownErrorFromSmartServer is raised.
2541
return context[name]
2542
except KeyError, key_err:
2543
mutter('Missing key %r in context %r', key_err.args[0], context)
2546
"""Get the path from the context if present, otherwise use first error
2550
return context['path']
2551
except KeyError, key_err:
2553
return err.error_args[0]
2554
except IndexError, idx_err:
2556
'Missing key %r in context %r', key_err.args[0], context)
2559
if err.error_verb == 'NoSuchRevision':
2560
raise NoSuchRevision(find('branch'), err.error_args[0])
2561
elif err.error_verb == 'nosuchrevision':
2562
raise NoSuchRevision(find('repository'), err.error_args[0])
2563
elif err.error_tuple == ('nobranch',):
2564
raise errors.NotBranchError(path=find('bzrdir').root_transport.base)
2565
elif err.error_verb == 'norepository':
2566
raise errors.NoRepositoryPresent(find('bzrdir'))
2567
elif err.error_verb == 'LockContention':
2568
raise errors.LockContention('(remote lock)')
2569
elif err.error_verb == 'UnlockableTransport':
2570
raise errors.UnlockableTransport(find('bzrdir').root_transport)
2571
elif err.error_verb == 'LockFailed':
2572
raise errors.LockFailed(err.error_args[0], err.error_args[1])
2573
elif err.error_verb == 'TokenMismatch':
2574
raise errors.TokenMismatch(find('token'), '(remote token)')
2575
elif err.error_verb == 'Diverged':
2576
raise errors.DivergedBranches(find('branch'), find('other_branch'))
2577
elif err.error_verb == 'TipChangeRejected':
2578
raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
2579
elif err.error_verb == 'UnstackableBranchFormat':
2580
raise errors.UnstackableBranchFormat(*err.error_args)
2581
elif err.error_verb == 'UnstackableRepositoryFormat':
2582
raise errors.UnstackableRepositoryFormat(*err.error_args)
2583
elif err.error_verb == 'NotStacked':
2584
raise errors.NotStacked(branch=find('branch'))
2585
elif err.error_verb == 'PermissionDenied':
2587
if len(err.error_args) >= 2:
2588
extra = err.error_args[1]
2591
raise errors.PermissionDenied(path, extra=extra)
2592
elif err.error_verb == 'ReadError':
2594
raise errors.ReadError(path)
2595
elif err.error_verb == 'NoSuchFile':
2597
raise errors.NoSuchFile(path)
2598
elif err.error_verb == 'FileExists':
2599
raise errors.FileExists(err.error_args[0])
2600
elif err.error_verb == 'DirectoryNotEmpty':
2601
raise errors.DirectoryNotEmpty(err.error_args[0])
2602
elif err.error_verb == 'ShortReadvError':
2603
args = err.error_args
2604
raise errors.ShortReadvError(
2605
args[0], int(args[1]), int(args[2]), int(args[3]))
2606
elif err.error_verb in ('UnicodeEncodeError', 'UnicodeDecodeError'):
2607
encoding = str(err.error_args[0]) # encoding must always be a string
2608
val = err.error_args[1]
2609
start = int(err.error_args[2])
2610
end = int(err.error_args[3])
2611
reason = str(err.error_args[4]) # reason must always be a string
2612
if val.startswith('u:'):
2613
val = val[2:].decode('utf-8')
2614
elif val.startswith('s:'):
2615
val = val[2:].decode('base64')
2616
if err.error_verb == 'UnicodeDecodeError':
2617
raise UnicodeDecodeError(encoding, val, start, end, reason)
2618
elif err.error_verb == 'UnicodeEncodeError':
2619
raise UnicodeEncodeError(encoding, val, start, end, reason)
2620
elif err.error_verb == 'ReadOnlyError':
2621
raise errors.TransportNotPossible('readonly transport')
2622
raise errors.UnknownErrorFromSmartServer(err)
added
removed
bzrlib/remote.py
