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.
35
from bzrlib.branch import BranchReferenceFormat
36
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
37
from bzrlib.decorators import needs_read_lock, needs_write_lock
38
from bzrlib.errors import (
42
from bzrlib.lockable_files import LockableFiles
43
from bzrlib.smart import client, vfs, repository as smart_repo
44
from bzrlib.revision import ensure_null, NULL_REVISION
45
from bzrlib.trace import mutter, note, warning
46
from bzrlib.util import bencode
49
class _RpcHelper(object):
50
"""Mixin class that helps with issuing RPCs."""
52
def _call(self, method, *args, **err_context):
54
return self._client.call(method, *args)
55
except errors.ErrorFromSmartServer, err:
56
self._translate_error(err, **err_context)
58
def _call_expecting_body(self, method, *args, **err_context):
60
return self._client.call_expecting_body(method, *args)
61
except errors.ErrorFromSmartServer, err:
62
self._translate_error(err, **err_context)
64
def _call_with_body_bytes_expecting_body(self, method, args, body_bytes,
67
return self._client.call_with_body_bytes_expecting_body(
68
method, args, body_bytes)
69
except errors.ErrorFromSmartServer, err:
70
self._translate_error(err, **err_context)
73
def response_tuple_to_repo_format(response):
74
"""Convert a response tuple describing a repository format to a format."""
75
format = RemoteRepositoryFormat()
76
format._rich_root_data = (response[0] == 'yes')
77
format._supports_tree_reference = (response[1] == 'yes')
78
format._supports_external_lookups = (response[2] == 'yes')
79
format._network_name = response[3]
83
# Note: RemoteBzrDirFormat is in bzrdir.py
85
class RemoteBzrDir(BzrDir, _RpcHelper):
86
"""Control directory on a remote server, accessed via bzr:// or similar."""
88
def __init__(self, transport, format, _client=None):
89
"""Construct a RemoteBzrDir.
91
:param _client: Private parameter for testing. Disables probing and the
94
BzrDir.__init__(self, transport, format)
95
# this object holds a delegated bzrdir that uses file-level operations
96
# to talk to the other side
97
self._real_bzrdir = None
98
# 1-shot cache for the call pattern 'create_branch; open_branch' - see
99
# create_branch for details.
100
self._next_open_branch_result = None
103
medium = transport.get_smart_medium()
104
self._client = client._SmartClient(medium)
106
self._client = _client
109
path = self._path_for_remote_call(self._client)
110
response = self._call('BzrDir.open', path)
111
if response not in [('yes',), ('no',)]:
112
raise errors.UnexpectedSmartServerResponse(response)
113
if response == ('no',):
114
raise errors.NotBranchError(path=transport.base)
116
def _ensure_real(self):
117
"""Ensure that there is a _real_bzrdir set.
119
Used before calls to self._real_bzrdir.
121
if not self._real_bzrdir:
122
self._real_bzrdir = BzrDir.open_from_transport(
123
self.root_transport, _server_formats=False)
124
self._format._network_name = \
125
self._real_bzrdir._format.network_name()
127
def _translate_error(self, err, **context):
128
_translate_error(err, bzrdir=self, **context)
130
def break_lock(self):
131
# Prevent aliasing problems in the next_open_branch_result cache.
132
# See create_branch for rationale.
133
self._next_open_branch_result = None
134
return BzrDir.break_lock(self)
136
def _vfs_cloning_metadir(self, require_stacking=False):
138
return self._real_bzrdir.cloning_metadir(
139
require_stacking=require_stacking)
141
def cloning_metadir(self, require_stacking=False):
142
medium = self._client._medium
143
if medium._is_remote_before((1, 13)):
144
return self._vfs_cloning_metadir(require_stacking=require_stacking)
145
verb = 'BzrDir.cloning_metadir'
150
path = self._path_for_remote_call(self._client)
152
response = self._call(verb, path, stacking)
153
except errors.UnknownSmartMethod:
154
medium._remember_remote_is_before((1, 13))
155
return self._vfs_cloning_metadir(require_stacking=require_stacking)
156
except errors.UnknownErrorFromSmartServer, err:
157
if err.error_tuple != ('BranchReference',):
159
# We need to resolve the branch reference to determine the
160
# cloning_metadir. This causes unnecessary RPCs to open the
161
# referenced branch (and bzrdir, etc) but only when the caller
162
# didn't already resolve the branch reference.
163
referenced_branch = self.open_branch()
164
return referenced_branch.bzrdir.cloning_metadir()
165
if len(response) != 3:
166
raise errors.UnexpectedSmartServerResponse(response)
167
control_name, repo_name, branch_info = response
168
if len(branch_info) != 2:
169
raise errors.UnexpectedSmartServerResponse(response)
170
branch_ref, branch_name = branch_info
171
format = bzrdir.network_format_registry.get(control_name)
173
format.repository_format = repository.network_format_registry.get(
175
if branch_ref == 'ref':
176
# XXX: we need possible_transports here to avoid reopening the
177
# connection to the referenced location
178
ref_bzrdir = BzrDir.open(branch_name)
179
branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
180
format.set_branch_format(branch_format)
181
elif branch_ref == 'branch':
183
format.set_branch_format(
184
branch.network_format_registry.get(branch_name))
186
raise errors.UnexpectedSmartServerResponse(response)
189
def create_repository(self, shared=False):
190
# as per meta1 formats - just delegate to the format object which may
192
result = self._format.repository_format.initialize(self, shared)
193
if not isinstance(result, RemoteRepository):
194
return self.open_repository()
198
def destroy_repository(self):
199
"""See BzrDir.destroy_repository"""
201
self._real_bzrdir.destroy_repository()
203
def create_branch(self):
204
# as per meta1 formats - just delegate to the format object which may
206
real_branch = self._format.get_branch_format().initialize(self)
207
if not isinstance(real_branch, RemoteBranch):
208
result = RemoteBranch(self, self.find_repository(), real_branch)
211
# BzrDir.clone_on_transport() uses the result of create_branch but does
212
# not return it to its callers; we save approximately 8% of our round
213
# trips by handing the branch we created back to the first caller to
214
# open_branch rather than probing anew. Long term we need a API in
215
# bzrdir that doesn't discard result objects (like result_branch).
217
self._next_open_branch_result = result
220
def destroy_branch(self):
221
"""See BzrDir.destroy_branch"""
223
self._real_bzrdir.destroy_branch()
224
self._next_open_branch_result = None
226
def create_workingtree(self, revision_id=None, from_branch=None):
227
raise errors.NotLocalUrl(self.transport.base)
229
def find_branch_format(self):
230
"""Find the branch 'format' for this bzrdir.
232
This might be a synthetic object for e.g. RemoteBranch and SVN.
234
b = self.open_branch()
237
def get_branch_reference(self):
238
"""See BzrDir.get_branch_reference()."""
239
response = self._get_branch_reference()
240
if response[0] == 'ref':
245
def _get_branch_reference(self):
246
path = self._path_for_remote_call(self._client)
247
medium = self._client._medium
248
if not medium._is_remote_before((1, 13)):
250
response = self._call('BzrDir.open_branchV2', path)
251
if response[0] not in ('ref', 'branch'):
252
raise errors.UnexpectedSmartServerResponse(response)
254
except errors.UnknownSmartMethod:
255
medium._remember_remote_is_before((1, 13))
256
response = self._call('BzrDir.open_branch', path)
257
if response[0] != 'ok':
258
raise errors.UnexpectedSmartServerResponse(response)
259
if response[1] != '':
260
return ('ref', response[1])
262
return ('branch', '')
264
def _get_tree_branch(self):
265
"""See BzrDir._get_tree_branch()."""
266
return None, self.open_branch()
268
def open_branch(self, _unsupported=False, ignore_fallbacks=False):
270
raise NotImplementedError('unsupported flag support not implemented yet.')
271
if self._next_open_branch_result is not None:
272
# See create_branch for details.
273
result = self._next_open_branch_result
274
self._next_open_branch_result = None
276
response = self._get_branch_reference()
277
if response[0] == 'ref':
278
# a branch reference, use the existing BranchReference logic.
279
format = BranchReferenceFormat()
280
return format.open(self, _found=True, location=response[1],
281
ignore_fallbacks=ignore_fallbacks)
282
branch_format_name = response[1]
283
if not branch_format_name:
284
branch_format_name = None
285
format = RemoteBranchFormat(network_name=branch_format_name)
286
return RemoteBranch(self, self.find_repository(), format=format,
287
setup_stacking=not ignore_fallbacks)
289
def _open_repo_v1(self, path):
290
verb = 'BzrDir.find_repository'
291
response = self._call(verb, path)
292
if response[0] != 'ok':
293
raise errors.UnexpectedSmartServerResponse(response)
294
# servers that only support the v1 method don't support external
297
repo = self._real_bzrdir.open_repository()
298
response = response + ('no', repo._format.network_name())
299
return response, repo
301
def _open_repo_v2(self, path):
302
verb = 'BzrDir.find_repositoryV2'
303
response = self._call(verb, path)
304
if response[0] != 'ok':
305
raise errors.UnexpectedSmartServerResponse(response)
307
repo = self._real_bzrdir.open_repository()
308
response = response + (repo._format.network_name(),)
309
return response, repo
311
def _open_repo_v3(self, path):
312
verb = 'BzrDir.find_repositoryV3'
313
medium = self._client._medium
314
if medium._is_remote_before((1, 13)):
315
raise errors.UnknownSmartMethod(verb)
317
response = self._call(verb, path)
318
except errors.UnknownSmartMethod:
319
medium._remember_remote_is_before((1, 13))
321
if response[0] != 'ok':
322
raise errors.UnexpectedSmartServerResponse(response)
323
return response, None
325
def open_repository(self):
326
path = self._path_for_remote_call(self._client)
328
for probe in [self._open_repo_v3, self._open_repo_v2,
331
response, real_repo = probe(path)
333
except errors.UnknownSmartMethod:
336
raise errors.UnknownSmartMethod('BzrDir.find_repository{3,2,}')
337
if response[0] != 'ok':
338
raise errors.UnexpectedSmartServerResponse(response)
339
if len(response) != 6:
340
raise SmartProtocolError('incorrect response length %s' % (response,))
341
if response[1] == '':
342
# repo is at this dir.
343
format = response_tuple_to_repo_format(response[2:])
344
# Used to support creating a real format instance when needed.
345
format._creating_bzrdir = self
346
remote_repo = RemoteRepository(self, format)
347
format._creating_repo = remote_repo
348
if real_repo is not None:
349
remote_repo._set_real_repository(real_repo)
352
raise errors.NoRepositoryPresent(self)
354
def open_workingtree(self, recommend_upgrade=True):
356
if self._real_bzrdir.has_workingtree():
357
raise errors.NotLocalUrl(self.root_transport)
359
raise errors.NoWorkingTree(self.root_transport.base)
361
def _path_for_remote_call(self, client):
362
"""Return the path to be used for this bzrdir in a remote call."""
363
return client.remote_path_from_transport(self.root_transport)
365
def get_branch_transport(self, branch_format):
367
return self._real_bzrdir.get_branch_transport(branch_format)
369
def get_repository_transport(self, repository_format):
371
return self._real_bzrdir.get_repository_transport(repository_format)
373
def get_workingtree_transport(self, workingtree_format):
375
return self._real_bzrdir.get_workingtree_transport(workingtree_format)
377
def can_convert_format(self):
378
"""Upgrading of remote bzrdirs is not supported yet."""
381
def needs_format_conversion(self, format=None):
382
"""Upgrading of remote bzrdirs is not supported yet."""
384
symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
385
% 'needs_format_conversion(format=None)')
388
def clone(self, url, revision_id=None, force_new_repo=False,
389
preserve_stacking=False):
391
return self._real_bzrdir.clone(url, revision_id=revision_id,
392
force_new_repo=force_new_repo, preserve_stacking=preserve_stacking)
394
def get_config(self):
396
return self._real_bzrdir.get_config()
399
class RemoteRepositoryFormat(repository.RepositoryFormat):
400
"""Format for repositories accessed over a _SmartClient.
402
Instances of this repository are represented by RemoteRepository
405
The RemoteRepositoryFormat is parameterized during construction
406
to reflect the capabilities of the real, remote format. Specifically
407
the attributes rich_root_data and supports_tree_reference are set
408
on a per instance basis, and are not set (and should not be) at
411
:ivar _custom_format: If set, a specific concrete repository format that
412
will be used when initializing a repository with this
413
RemoteRepositoryFormat.
414
:ivar _creating_repo: If set, the repository object that this
415
RemoteRepositoryFormat was created for: it can be called into
416
to obtain data like the network name.
419
_matchingbzrdir = RemoteBzrDirFormat()
422
repository.RepositoryFormat.__init__(self)
423
self._custom_format = None
424
self._network_name = None
425
self._creating_bzrdir = None
426
self._supports_external_lookups = None
427
self._supports_tree_reference = None
428
self._rich_root_data = None
431
def fast_deltas(self):
433
return self._custom_format.fast_deltas
436
def rich_root_data(self):
437
if self._rich_root_data is None:
439
self._rich_root_data = self._custom_format.rich_root_data
440
return self._rich_root_data
443
def supports_external_lookups(self):
444
if self._supports_external_lookups is None:
446
self._supports_external_lookups = \
447
self._custom_format.supports_external_lookups
448
return self._supports_external_lookups
451
def supports_tree_reference(self):
452
if self._supports_tree_reference is None:
454
self._supports_tree_reference = \
455
self._custom_format.supports_tree_reference
456
return self._supports_tree_reference
458
def _vfs_initialize(self, a_bzrdir, shared):
459
"""Helper for common code in initialize."""
460
if self._custom_format:
461
# Custom format requested
462
result = self._custom_format.initialize(a_bzrdir, shared=shared)
463
elif self._creating_bzrdir is not None:
464
# Use the format that the repository we were created to back
466
prior_repo = self._creating_bzrdir.open_repository()
467
prior_repo._ensure_real()
468
result = prior_repo._real_repository._format.initialize(
469
a_bzrdir, shared=shared)
471
# assume that a_bzr is a RemoteBzrDir but the smart server didn't
472
# support remote initialization.
473
# We delegate to a real object at this point (as RemoteBzrDir
474
# delegate to the repository format which would lead to infinite
475
# recursion if we just called a_bzrdir.create_repository.
476
a_bzrdir._ensure_real()
477
result = a_bzrdir._real_bzrdir.create_repository(shared=shared)
478
if not isinstance(result, RemoteRepository):
479
return self.open(a_bzrdir)
483
def initialize(self, a_bzrdir, shared=False):
484
# Being asked to create on a non RemoteBzrDir:
485
if not isinstance(a_bzrdir, RemoteBzrDir):
486
return self._vfs_initialize(a_bzrdir, shared)
487
medium = a_bzrdir._client._medium
488
if medium._is_remote_before((1, 13)):
489
return self._vfs_initialize(a_bzrdir, shared)
490
# Creating on a remote bzr dir.
491
# 1) get the network name to use.
492
if self._custom_format:
493
network_name = self._custom_format.network_name()
495
# Select the current bzrlib default and ask for that.
496
reference_bzrdir_format = bzrdir.format_registry.get('default')()
497
reference_format = reference_bzrdir_format.repository_format
498
network_name = reference_format.network_name()
499
# 2) try direct creation via RPC
500
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
501
verb = 'BzrDir.create_repository'
507
response = a_bzrdir._call(verb, path, network_name, shared_str)
508
except errors.UnknownSmartMethod:
509
# Fallback - use vfs methods
510
medium._remember_remote_is_before((1, 13))
511
return self._vfs_initialize(a_bzrdir, shared)
513
# Turn the response into a RemoteRepository object.
514
format = response_tuple_to_repo_format(response[1:])
515
# Used to support creating a real format instance when needed.
516
format._creating_bzrdir = a_bzrdir
517
remote_repo = RemoteRepository(a_bzrdir, format)
518
format._creating_repo = remote_repo
521
def open(self, a_bzrdir):
522
if not isinstance(a_bzrdir, RemoteBzrDir):
523
raise AssertionError('%r is not a RemoteBzrDir' % (a_bzrdir,))
524
return a_bzrdir.open_repository()
526
def _ensure_real(self):
527
if self._custom_format is None:
528
self._custom_format = repository.network_format_registry.get(
532
def _fetch_order(self):
534
return self._custom_format._fetch_order
537
def _fetch_uses_deltas(self):
539
return self._custom_format._fetch_uses_deltas
542
def _fetch_reconcile(self):
544
return self._custom_format._fetch_reconcile
546
def get_format_description(self):
547
return 'bzr remote repository'
549
def __eq__(self, other):
550
return self.__class__ is other.__class__
552
def check_conversion_target(self, target_format):
553
if self.rich_root_data and not target_format.rich_root_data:
554
raise errors.BadConversionTarget(
555
'Does not support rich root data.', target_format)
556
if (self.supports_tree_reference and
557
not getattr(target_format, 'supports_tree_reference', False)):
558
raise errors.BadConversionTarget(
559
'Does not support nested trees', target_format)
561
def network_name(self):
562
if self._network_name:
563
return self._network_name
564
self._creating_repo._ensure_real()
565
return self._creating_repo._real_repository._format.network_name()
568
def _serializer(self):
570
return self._custom_format._serializer
573
class RemoteRepository(_RpcHelper):
574
"""Repository accessed over rpc.
576
For the moment most operations are performed using local transport-backed
580
def __init__(self, remote_bzrdir, format, real_repository=None, _client=None):
581
"""Create a RemoteRepository instance.
583
:param remote_bzrdir: The bzrdir hosting this repository.
584
:param format: The RemoteFormat object to use.
585
:param real_repository: If not None, a local implementation of the
586
repository logic for the repository, usually accessing the data
588
:param _client: Private testing parameter - override the smart client
589
to be used by the repository.
592
self._real_repository = real_repository
594
self._real_repository = None
595
self.bzrdir = remote_bzrdir
597
self._client = remote_bzrdir._client
599
self._client = _client
600
self._format = format
601
self._lock_mode = None
602
self._lock_token = None
604
self._leave_lock = False
605
self._unstacked_provider = graph.CachingParentsProvider(
606
get_parent_map=self._get_parent_map_rpc)
607
self._unstacked_provider.disable_cache()
609
# These depend on the actual remote format, so force them off for
610
# maximum compatibility. XXX: In future these should depend on the
611
# remote repository instance, but this is irrelevant until we perform
612
# reconcile via an RPC call.
613
self._reconcile_does_inventory_gc = False
614
self._reconcile_fixes_text_parents = False
615
self._reconcile_backsup_inventory = False
616
self.base = self.bzrdir.transport.base
617
# Additional places to query for data.
618
self._fallback_repositories = []
621
return "%s(%s)" % (self.__class__.__name__, self.base)
625
def abort_write_group(self, suppress_errors=False):
626
"""Complete a write group on the decorated repository.
628
Smart methods peform operations in a single step so this api
629
is not really applicable except as a compatibility thunk
630
for older plugins that don't use e.g. the CommitBuilder
633
:param suppress_errors: see Repository.abort_write_group.
636
return self._real_repository.abort_write_group(
637
suppress_errors=suppress_errors)
639
def commit_write_group(self):
640
"""Complete a write group on the decorated repository.
642
Smart methods peform operations in a single step so this api
643
is not really applicable except as a compatibility thunk
644
for older plugins that don't use e.g. the CommitBuilder
648
return self._real_repository.commit_write_group()
650
def resume_write_group(self, tokens):
652
return self._real_repository.resume_write_group(tokens)
654
def suspend_write_group(self):
656
return self._real_repository.suspend_write_group()
658
def _ensure_real(self):
659
"""Ensure that there is a _real_repository set.
661
Used before calls to self._real_repository.
663
Note that _ensure_real causes many roundtrips to the server which are
664
not desirable, and prevents the use of smart one-roundtrip RPC's to
665
perform complex operations (such as accessing parent data, streaming
666
revisions etc). Adding calls to _ensure_real should only be done when
667
bringing up new functionality, adding fallbacks for smart methods that
668
require a fallback path, and never to replace an existing smart method
669
invocation. If in doubt chat to the bzr network team.
671
if self._real_repository is None:
672
self.bzrdir._ensure_real()
673
self._set_real_repository(
674
self.bzrdir._real_bzrdir.open_repository())
676
def _translate_error(self, err, **context):
677
self.bzrdir._translate_error(err, repository=self, **context)
679
def find_text_key_references(self):
680
"""Find the text key references within the repository.
682
:return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
683
revision_ids. Each altered file-ids has the exact revision_ids that
684
altered it listed explicitly.
685
:return: A dictionary mapping text keys ((fileid, revision_id) tuples)
686
to whether they were referred to by the inventory of the
687
revision_id that they contain. The inventory texts from all present
688
revision ids are assessed to generate this report.
691
return self._real_repository.find_text_key_references()
693
def _generate_text_key_index(self):
694
"""Generate a new text key index for the repository.
696
This is an expensive function that will take considerable time to run.
698
:return: A dict mapping (file_id, revision_id) tuples to a list of
699
parents, also (file_id, revision_id) tuples.
702
return self._real_repository._generate_text_key_index()
704
def _get_revision_graph(self, revision_id):
705
"""Private method for using with old (< 1.2) servers to fallback."""
706
if revision_id is None:
708
elif revision.is_null(revision_id):
711
path = self.bzrdir._path_for_remote_call(self._client)
712
response = self._call_expecting_body(
713
'Repository.get_revision_graph', path, revision_id)
714
response_tuple, response_handler = response
715
if response_tuple[0] != 'ok':
716
raise errors.UnexpectedSmartServerResponse(response_tuple)
717
coded = response_handler.read_body_bytes()
719
# no revisions in this repository!
721
lines = coded.split('\n')
724
d = tuple(line.split())
725
revision_graph[d[0]] = d[1:]
727
return revision_graph
730
"""See Repository._get_sink()."""
731
return RemoteStreamSink(self)
733
def _get_source(self, to_format):
734
"""Return a source for streaming from this repository."""
735
return RemoteStreamSource(self, to_format)
737
def has_revision(self, revision_id):
738
"""See Repository.has_revision()."""
739
if revision_id == NULL_REVISION:
740
# The null revision is always present.
742
path = self.bzrdir._path_for_remote_call(self._client)
743
response = self._call('Repository.has_revision', path, revision_id)
744
if response[0] not in ('yes', 'no'):
745
raise errors.UnexpectedSmartServerResponse(response)
746
if response[0] == 'yes':
748
for fallback_repo in self._fallback_repositories:
749
if fallback_repo.has_revision(revision_id):
753
def has_revisions(self, revision_ids):
754
"""See Repository.has_revisions()."""
755
# FIXME: This does many roundtrips, particularly when there are
756
# fallback repositories. -- mbp 20080905
758
for revision_id in revision_ids:
759
if self.has_revision(revision_id):
760
result.add(revision_id)
763
def has_same_location(self, other):
764
return (self.__class__ is other.__class__ and
765
self.bzrdir.transport.base == other.bzrdir.transport.base)
767
def get_graph(self, other_repository=None):
768
"""Return the graph for this repository format"""
769
parents_provider = self._make_parents_provider(other_repository)
770
return graph.Graph(parents_provider)
772
def gather_stats(self, revid=None, committers=None):
773
"""See Repository.gather_stats()."""
774
path = self.bzrdir._path_for_remote_call(self._client)
775
# revid can be None to indicate no revisions, not just NULL_REVISION
776
if revid is None or revision.is_null(revid):
780
if committers is None or not committers:
781
fmt_committers = 'no'
783
fmt_committers = 'yes'
784
response_tuple, response_handler = self._call_expecting_body(
785
'Repository.gather_stats', path, fmt_revid, fmt_committers)
786
if response_tuple[0] != 'ok':
787
raise errors.UnexpectedSmartServerResponse(response_tuple)
789
body = response_handler.read_body_bytes()
791
for line in body.split('\n'):
794
key, val_text = line.split(':')
795
if key in ('revisions', 'size', 'committers'):
796
result[key] = int(val_text)
797
elif key in ('firstrev', 'latestrev'):
798
values = val_text.split(' ')[1:]
799
result[key] = (float(values[0]), long(values[1]))
803
def find_branches(self, using=False):
804
"""See Repository.find_branches()."""
805
# should be an API call to the server.
807
return self._real_repository.find_branches(using=using)
809
def get_physical_lock_status(self):
810
"""See Repository.get_physical_lock_status()."""
811
# should be an API call to the server.
813
return self._real_repository.get_physical_lock_status()
815
def is_in_write_group(self):
816
"""Return True if there is an open write group.
818
write groups are only applicable locally for the smart server..
820
if self._real_repository:
821
return self._real_repository.is_in_write_group()
824
return self._lock_count >= 1
827
"""See Repository.is_shared()."""
828
path = self.bzrdir._path_for_remote_call(self._client)
829
response = self._call('Repository.is_shared', path)
830
if response[0] not in ('yes', 'no'):
831
raise SmartProtocolError('unexpected response code %s' % (response,))
832
return response[0] == 'yes'
834
def is_write_locked(self):
835
return self._lock_mode == 'w'
838
# wrong eventually - want a local lock cache context
839
if not self._lock_mode:
840
self._lock_mode = 'r'
842
self._unstacked_provider.enable_cache(cache_misses=True)
843
if self._real_repository is not None:
844
self._real_repository.lock_read()
846
self._lock_count += 1
848
def _remote_lock_write(self, token):
849
path = self.bzrdir._path_for_remote_call(self._client)
852
err_context = {'token': token}
853
response = self._call('Repository.lock_write', path, token,
855
if response[0] == 'ok':
859
raise errors.UnexpectedSmartServerResponse(response)
861
def lock_write(self, token=None, _skip_rpc=False):
862
if not self._lock_mode:
864
if self._lock_token is not None:
865
if token != self._lock_token:
866
raise errors.TokenMismatch(token, self._lock_token)
867
self._lock_token = token
869
self._lock_token = self._remote_lock_write(token)
870
# if self._lock_token is None, then this is something like packs or
871
# svn where we don't get to lock the repo, or a weave style repository
872
# where we cannot lock it over the wire and attempts to do so will
874
if self._real_repository is not None:
875
self._real_repository.lock_write(token=self._lock_token)
876
if token is not None:
877
self._leave_lock = True
879
self._leave_lock = False
880
self._lock_mode = 'w'
882
self._unstacked_provider.enable_cache(cache_misses=False)
883
elif self._lock_mode == 'r':
884
raise errors.ReadOnlyError(self)
886
self._lock_count += 1
887
return self._lock_token or None
889
def leave_lock_in_place(self):
890
if not self._lock_token:
891
raise NotImplementedError(self.leave_lock_in_place)
892
self._leave_lock = True
894
def dont_leave_lock_in_place(self):
895
if not self._lock_token:
896
raise NotImplementedError(self.dont_leave_lock_in_place)
897
self._leave_lock = False
899
def _set_real_repository(self, repository):
900
"""Set the _real_repository for this repository.
902
:param repository: The repository to fallback to for non-hpss
903
implemented operations.
905
if self._real_repository is not None:
906
# Replacing an already set real repository.
907
# We cannot do this [currently] if the repository is locked -
908
# synchronised state might be lost.
910
raise AssertionError('_real_repository is already set')
911
if isinstance(repository, RemoteRepository):
912
raise AssertionError()
913
self._real_repository = repository
914
# If the _real_repository has _fallback_repositories, clear them out,
915
# because we want it to have the same set as this repository. This is
916
# reasonable to do because the fallbacks we clear here are from a
917
# "real" branch, and we're about to replace them with the equivalents
918
# from a RemoteBranch.
919
self._real_repository._fallback_repositories = []
920
for fb in self._fallback_repositories:
921
self._real_repository.add_fallback_repository(fb)
922
if self._lock_mode == 'w':
923
# if we are already locked, the real repository must be able to
924
# acquire the lock with our token.
925
self._real_repository.lock_write(self._lock_token)
926
elif self._lock_mode == 'r':
927
self._real_repository.lock_read()
929
def start_write_group(self):
930
"""Start a write group on the decorated repository.
932
Smart methods peform operations in a single step so this api
933
is not really applicable except as a compatibility thunk
934
for older plugins that don't use e.g. the CommitBuilder
938
return self._real_repository.start_write_group()
940
def _unlock(self, token):
941
path = self.bzrdir._path_for_remote_call(self._client)
943
# with no token the remote repository is not persistently locked.
945
err_context = {'token': token}
946
response = self._call('Repository.unlock', path, token,
948
if response == ('ok',):
951
raise errors.UnexpectedSmartServerResponse(response)
954
if not self._lock_count:
955
raise errors.LockNotHeld(self)
956
self._lock_count -= 1
957
if self._lock_count > 0:
959
self._unstacked_provider.disable_cache()
960
old_mode = self._lock_mode
961
self._lock_mode = None
963
# The real repository is responsible at present for raising an
964
# exception if it's in an unfinished write group. However, it
965
# normally will *not* actually remove the lock from disk - that's
966
# done by the server on receiving the Repository.unlock call.
967
# This is just to let the _real_repository stay up to date.
968
if self._real_repository is not None:
969
self._real_repository.unlock()
971
# The rpc-level lock should be released even if there was a
972
# problem releasing the vfs-based lock.
974
# Only write-locked repositories need to make a remote method
975
# call to perfom the unlock.
976
old_token = self._lock_token
977
self._lock_token = None
978
if not self._leave_lock:
979
self._unlock(old_token)
981
def break_lock(self):
982
# should hand off to the network
984
return self._real_repository.break_lock()
986
def _get_tarball(self, compression):
987
"""Return a TemporaryFile containing a repository tarball.
989
Returns None if the server does not support sending tarballs.
992
path = self.bzrdir._path_for_remote_call(self._client)
994
response, protocol = self._call_expecting_body(
995
'Repository.tarball', path, compression)
996
except errors.UnknownSmartMethod:
997
protocol.cancel_read_body()
999
if response[0] == 'ok':
1000
# Extract the tarball and return it
1001
t = tempfile.NamedTemporaryFile()
1002
# TODO: rpc layer should read directly into it...
1003
t.write(protocol.read_body_bytes())
1006
raise errors.UnexpectedSmartServerResponse(response)
1008
def sprout(self, to_bzrdir, revision_id=None):
1009
# TODO: Option to control what format is created?
1011
dest_repo = self._real_repository._format.initialize(to_bzrdir,
1013
dest_repo.fetch(self, revision_id=revision_id)
1016
### These methods are just thin shims to the VFS object for now.
1018
def revision_tree(self, revision_id):
1020
return self._real_repository.revision_tree(revision_id)
1022
def get_serializer_format(self):
1024
return self._real_repository.get_serializer_format()
1026
def get_commit_builder(self, branch, parents, config, timestamp=None,
1027
timezone=None, committer=None, revprops=None,
1029
# FIXME: It ought to be possible to call this without immediately
1030
# triggering _ensure_real. For now it's the easiest thing to do.
1032
real_repo = self._real_repository
1033
builder = real_repo.get_commit_builder(branch, parents,
1034
config, timestamp=timestamp, timezone=timezone,
1035
committer=committer, revprops=revprops, revision_id=revision_id)
1038
def add_fallback_repository(self, repository):
1039
"""Add a repository to use for looking up data not held locally.
1041
:param repository: A repository.
1043
if not self._format.supports_external_lookups:
1044
raise errors.UnstackableRepositoryFormat(
1045
self._format.network_name(), self.base)
1046
# We need to accumulate additional repositories here, to pass them in
1049
self._fallback_repositories.append(repository)
1050
# If self._real_repository was parameterised already (e.g. because a
1051
# _real_branch had its get_stacked_on_url method called), then the
1052
# repository to be added may already be in the _real_repositories list.
1053
if self._real_repository is not None:
1054
if repository not in self._real_repository._fallback_repositories:
1055
self._real_repository.add_fallback_repository(repository)
1057
# They are also seen by the fallback repository. If it doesn't
1058
# exist yet they'll be added then. This implicitly copies them.
1061
def add_inventory(self, revid, inv, parents):
1063
return self._real_repository.add_inventory(revid, inv, parents)
1065
def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1068
return self._real_repository.add_inventory_by_delta(basis_revision_id,
1069
delta, new_revision_id, parents)
1071
def add_revision(self, rev_id, rev, inv=None, config=None):
1073
return self._real_repository.add_revision(
1074
rev_id, rev, inv=inv, config=config)
1077
def get_inventory(self, revision_id):
1079
return self._real_repository.get_inventory(revision_id)
1081
def iter_inventories(self, revision_ids):
1083
return self._real_repository.iter_inventories(revision_ids)
1086
def get_revision(self, revision_id):
1088
return self._real_repository.get_revision(revision_id)
1090
def get_transaction(self):
1092
return self._real_repository.get_transaction()
1095
def clone(self, a_bzrdir, revision_id=None):
1097
return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
1099
def make_working_trees(self):
1100
"""See Repository.make_working_trees"""
1102
return self._real_repository.make_working_trees()
1104
def refresh_data(self):
1105
"""Re-read any data needed to to synchronise with disk.
1107
This method is intended to be called after another repository instance
1108
(such as one used by a smart server) has inserted data into the
1109
repository. It may not be called during a write group, but may be
1110
called at any other time.
1112
if self.is_in_write_group():
1113
raise errors.InternalBzrError(
1114
"May not refresh_data while in a write group.")
1115
if self._real_repository is not None:
1116
self._real_repository.refresh_data()
1118
def revision_ids_to_search_result(self, result_set):
1119
"""Convert a set of revision ids to a graph SearchResult."""
1120
result_parents = set()
1121
for parents in self.get_graph().get_parent_map(
1122
result_set).itervalues():
1123
result_parents.update(parents)
1124
included_keys = result_set.intersection(result_parents)
1125
start_keys = result_set.difference(included_keys)
1126
exclude_keys = result_parents.difference(result_set)
1127
result = graph.SearchResult(start_keys, exclude_keys,
1128
len(result_set), result_set)
1132
def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1133
"""Return the revision ids that other has that this does not.
1135
These are returned in topological order.
1137
revision_id: only return revision ids included by revision_id.
1139
return repository.InterRepository.get(
1140
other, self).search_missing_revision_ids(revision_id, find_ghosts)
1142
def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
1144
# No base implementation to use as RemoteRepository is not a subclass
1145
# of Repository; so this is a copy of Repository.fetch().
1146
if fetch_spec is not None and revision_id is not None:
1147
raise AssertionError(
1148
"fetch_spec and revision_id are mutually exclusive.")
1149
if self.is_in_write_group():
1150
raise errors.InternalBzrError(
1151
"May not fetch while in a write group.")
1152
# fast path same-url fetch operations
1153
if self.has_same_location(source) and fetch_spec is None:
1154
# check that last_revision is in 'from' and then return a
1156
if (revision_id is not None and
1157
not revision.is_null(revision_id)):
1158
self.get_revision(revision_id)
1160
# if there is no specific appropriate InterRepository, this will get
1161
# the InterRepository base class, which raises an
1162
# IncompatibleRepositories when asked to fetch.
1163
inter = repository.InterRepository.get(source, self)
1164
return inter.fetch(revision_id=revision_id, pb=pb,
1165
find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1167
def create_bundle(self, target, base, fileobj, format=None):
1169
self._real_repository.create_bundle(target, base, fileobj, format)
1172
def get_ancestry(self, revision_id, topo_sorted=True):
1174
return self._real_repository.get_ancestry(revision_id, topo_sorted)
1176
def fileids_altered_by_revision_ids(self, revision_ids):
1178
return self._real_repository.fileids_altered_by_revision_ids(revision_ids)
1180
def _get_versioned_file_checker(self, revisions, revision_versions_cache):
1182
return self._real_repository._get_versioned_file_checker(
1183
revisions, revision_versions_cache)
1185
def iter_files_bytes(self, desired_files):
1186
"""See Repository.iter_file_bytes.
1189
return self._real_repository.iter_files_bytes(desired_files)
1191
def get_parent_map(self, revision_ids):
1192
"""See bzrlib.Graph.get_parent_map()."""
1193
return self._make_parents_provider().get_parent_map(revision_ids)
1195
def _get_parent_map_rpc(self, keys):
1196
"""Helper for get_parent_map that performs the RPC."""
1197
medium = self._client._medium
1198
if medium._is_remote_before((1, 2)):
1199
# We already found out that the server can't understand
1200
# Repository.get_parent_map requests, so just fetch the whole
1203
# Note that this reads the whole graph, when only some keys are
1204
# wanted. On this old server there's no way (?) to get them all
1205
# in one go, and the user probably will have seen a warning about
1206
# the server being old anyhow.
1207
rg = self._get_revision_graph(None)
1208
# There is an api discrepency between get_parent_map and
1209
# get_revision_graph. Specifically, a "key:()" pair in
1210
# get_revision_graph just means a node has no parents. For
1211
# "get_parent_map" it means the node is a ghost. So fix up the
1212
# graph to correct this.
1213
# https://bugs.launchpad.net/bzr/+bug/214894
1214
# There is one other "bug" which is that ghosts in
1215
# get_revision_graph() are not returned at all. But we won't worry
1216
# about that for now.
1217
for node_id, parent_ids in rg.iteritems():
1218
if parent_ids == ():
1219
rg[node_id] = (NULL_REVISION,)
1220
rg[NULL_REVISION] = ()
1225
raise ValueError('get_parent_map(None) is not valid')
1226
if NULL_REVISION in keys:
1227
keys.discard(NULL_REVISION)
1228
found_parents = {NULL_REVISION:()}
1230
return found_parents
1233
# TODO(Needs analysis): We could assume that the keys being requested
1234
# from get_parent_map are in a breadth first search, so typically they
1235
# will all be depth N from some common parent, and we don't have to
1236
# have the server iterate from the root parent, but rather from the
1237
# keys we're searching; and just tell the server the keyspace we
1238
# already have; but this may be more traffic again.
1240
# Transform self._parents_map into a search request recipe.
1241
# TODO: Manage this incrementally to avoid covering the same path
1242
# repeatedly. (The server will have to on each request, but the less
1243
# work done the better).
1245
# Negative caching notes:
1246
# new server sends missing when a request including the revid
1247
# 'include-missing:' is present in the request.
1248
# missing keys are serialised as missing:X, and we then call
1249
# provider.note_missing(X) for-all X
1250
parents_map = self._unstacked_provider.get_cached_map()
1251
if parents_map is None:
1252
# Repository is not locked, so there's no cache.
1254
# start_set is all the keys in the cache
1255
start_set = set(parents_map)
1256
# result set is all the references to keys in the cache
1257
result_parents = set()
1258
for parents in parents_map.itervalues():
1259
result_parents.update(parents)
1260
stop_keys = result_parents.difference(start_set)
1261
# We don't need to send ghosts back to the server as a position to
1263
stop_keys.difference_update(self._unstacked_provider.missing_keys)
1264
key_count = len(parents_map)
1265
if (NULL_REVISION in result_parents
1266
and NULL_REVISION in self._unstacked_provider.missing_keys):
1267
# If we pruned NULL_REVISION from the stop_keys because it's also
1268
# in our cache of "missing" keys we need to increment our key count
1269
# by 1, because the reconsitituted SearchResult on the server will
1270
# still consider NULL_REVISION to be an included key.
1272
included_keys = start_set.intersection(result_parents)
1273
start_set.difference_update(included_keys)
1274
recipe = ('manual', start_set, stop_keys, key_count)
1275
body = self._serialise_search_recipe(recipe)
1276
path = self.bzrdir._path_for_remote_call(self._client)
1278
if type(key) is not str:
1280
"key %r not a plain string" % (key,))
1281
verb = 'Repository.get_parent_map'
1282
args = (path, 'include-missing:') + tuple(keys)
1284
response = self._call_with_body_bytes_expecting_body(
1286
except errors.UnknownSmartMethod:
1287
# Server does not support this method, so get the whole graph.
1288
# Worse, we have to force a disconnection, because the server now
1289
# doesn't realise it has a body on the wire to consume, so the
1290
# only way to recover is to abandon the connection.
1292
'Server is too old for fast get_parent_map, reconnecting. '
1293
'(Upgrade the server to Bazaar 1.2 to avoid this)')
1295
# To avoid having to disconnect repeatedly, we keep track of the
1296
# fact the server doesn't understand remote methods added in 1.2.
1297
medium._remember_remote_is_before((1, 2))
1298
# Recurse just once and we should use the fallback code.
1299
return self._get_parent_map_rpc(keys)
1300
response_tuple, response_handler = response
1301
if response_tuple[0] not in ['ok']:
1302
response_handler.cancel_read_body()
1303
raise errors.UnexpectedSmartServerResponse(response_tuple)
1304
if response_tuple[0] == 'ok':
1305
coded = bz2.decompress(response_handler.read_body_bytes())
1307
# no revisions found
1309
lines = coded.split('\n')
1312
d = tuple(line.split())
1314
revision_graph[d[0]] = d[1:]
1317
if d[0].startswith('missing:'):
1319
self._unstacked_provider.note_missing_key(revid)
1321
# no parents - so give the Graph result
1323
revision_graph[d[0]] = (NULL_REVISION,)
1324
return revision_graph
1327
def get_signature_text(self, revision_id):
1329
return self._real_repository.get_signature_text(revision_id)
1332
def get_inventory_xml(self, revision_id):
1334
return self._real_repository.get_inventory_xml(revision_id)
1336
def deserialise_inventory(self, revision_id, xml):
1338
return self._real_repository.deserialise_inventory(revision_id, xml)
1340
def reconcile(self, other=None, thorough=False):
1342
return self._real_repository.reconcile(other=other, thorough=thorough)
1344
def all_revision_ids(self):
1346
return self._real_repository.all_revision_ids()
1349
def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1351
return self._real_repository.get_deltas_for_revisions(revisions,
1352
specific_fileids=specific_fileids)
1355
def get_revision_delta(self, revision_id, specific_fileids=None):
1357
return self._real_repository.get_revision_delta(revision_id,
1358
specific_fileids=specific_fileids)
1361
def revision_trees(self, revision_ids):
1363
return self._real_repository.revision_trees(revision_ids)
1366
def get_revision_reconcile(self, revision_id):
1368
return self._real_repository.get_revision_reconcile(revision_id)
1371
def check(self, revision_ids=None):
1373
return self._real_repository.check(revision_ids=revision_ids)
1375
def copy_content_into(self, destination, revision_id=None):
1377
return self._real_repository.copy_content_into(
1378
destination, revision_id=revision_id)
1380
def _copy_repository_tarball(self, to_bzrdir, revision_id=None):
1381
# get a tarball of the remote repository, and copy from that into the
1383
from bzrlib import osutils
1385
# TODO: Maybe a progress bar while streaming the tarball?
1386
note("Copying repository content as tarball...")
1387
tar_file = self._get_tarball('bz2')
1388
if tar_file is None:
1390
destination = to_bzrdir.create_repository()
1392
tar = tarfile.open('repository', fileobj=tar_file,
1394
tmpdir = osutils.mkdtemp()
1396
_extract_tar(tar, tmpdir)
1397
tmp_bzrdir = BzrDir.open(tmpdir)
1398
tmp_repo = tmp_bzrdir.open_repository()
1399
tmp_repo.copy_content_into(destination, revision_id)
1401
osutils.rmtree(tmpdir)
1405
# TODO: Suggestion from john: using external tar is much faster than
1406
# python's tarfile library, but it may not work on windows.
1409
def inventories(self):
1410
"""Decorate the real repository for now.
1412
In the long term a full blown network facility is needed to
1413
avoid creating a real repository object locally.
1416
return self._real_repository.inventories
1420
"""Compress the data within the repository.
1422
This is not currently implemented within the smart server.
1425
return self._real_repository.pack()
1428
def revisions(self):
1429
"""Decorate the real repository for now.
1431
In the short term this should become a real object to intercept graph
1434
In the long term a full blown network facility is needed.
1437
return self._real_repository.revisions
1439
def set_make_working_trees(self, new_value):
1441
new_value_str = "True"
1443
new_value_str = "False"
1444
path = self.bzrdir._path_for_remote_call(self._client)
1446
response = self._call(
1447
'Repository.set_make_working_trees', path, new_value_str)
1448
except errors.UnknownSmartMethod:
1450
self._real_repository.set_make_working_trees(new_value)
1452
if response[0] != 'ok':
1453
raise errors.UnexpectedSmartServerResponse(response)
1456
def signatures(self):
1457
"""Decorate the real repository for now.
1459
In the long term a full blown network facility is needed to avoid
1460
creating a real repository object locally.
1463
return self._real_repository.signatures
1466
def sign_revision(self, revision_id, gpg_strategy):
1468
return self._real_repository.sign_revision(revision_id, gpg_strategy)
1472
"""Decorate the real repository for now.
1474
In the long term a full blown network facility is needed to avoid
1475
creating a real repository object locally.
1478
return self._real_repository.texts
1481
def get_revisions(self, revision_ids):
1483
return self._real_repository.get_revisions(revision_ids)
1485
def supports_rich_root(self):
1486
return self._format.rich_root_data
1488
def iter_reverse_revision_history(self, revision_id):
1490
return self._real_repository.iter_reverse_revision_history(revision_id)
1493
def _serializer(self):
1494
return self._format._serializer
1496
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1498
return self._real_repository.store_revision_signature(
1499
gpg_strategy, plaintext, revision_id)
1501
def add_signature_text(self, revision_id, signature):
1503
return self._real_repository.add_signature_text(revision_id, signature)
1505
def has_signature_for_revision_id(self, revision_id):
1507
return self._real_repository.has_signature_for_revision_id(revision_id)
1509
def item_keys_introduced_by(self, revision_ids, _files_pb=None):
1511
return self._real_repository.item_keys_introduced_by(revision_ids,
1512
_files_pb=_files_pb)
1514
def revision_graph_can_have_wrong_parents(self):
1515
# The answer depends on the remote repo format.
1517
return self._real_repository.revision_graph_can_have_wrong_parents()
1519
def _find_inconsistent_revision_parents(self):
1521
return self._real_repository._find_inconsistent_revision_parents()
1523
def _check_for_inconsistent_revision_parents(self):
1525
return self._real_repository._check_for_inconsistent_revision_parents()
1527
def _make_parents_provider(self, other=None):
1528
providers = [self._unstacked_provider]
1529
if other is not None:
1530
providers.insert(0, other)
1531
providers.extend(r._make_parents_provider() for r in
1532
self._fallback_repositories)
1533
return graph._StackedParentsProvider(providers)
1535
def _serialise_search_recipe(self, recipe):
1536
"""Serialise a graph search recipe.
1538
:param recipe: A search recipe (start, stop, count).
1539
:return: Serialised bytes.
1541
start_keys = ' '.join(recipe[1])
1542
stop_keys = ' '.join(recipe[2])
1543
count = str(recipe[3])
1544
return '\n'.join((start_keys, stop_keys, count))
1546
def _serialise_search_result(self, search_result):
1547
if isinstance(search_result, graph.PendingAncestryResult):
1548
parts = ['ancestry-of']
1549
parts.extend(search_result.heads)
1551
recipe = search_result.get_recipe()
1552
parts = [recipe[0], self._serialise_search_recipe(recipe)]
1553
return '\n'.join(parts)
1556
path = self.bzrdir._path_for_remote_call(self._client)
1558
response = self._call('PackRepository.autopack', path)
1559
except errors.UnknownSmartMethod:
1561
self._real_repository._pack_collection.autopack()
1564
if response[0] != 'ok':
1565
raise errors.UnexpectedSmartServerResponse(response)
1568
class RemoteStreamSink(repository.StreamSink):
1570
def _insert_real(self, stream, src_format, resume_tokens):
1571
self.target_repo._ensure_real()
1572
sink = self.target_repo._real_repository._get_sink()
1573
result = sink.insert_stream(stream, src_format, resume_tokens)
1575
self.target_repo.autopack()
1578
def insert_stream(self, stream, src_format, resume_tokens):
1579
target = self.target_repo
1580
if target._lock_token:
1581
verb = 'Repository.insert_stream_locked'
1582
extra_args = (target._lock_token or '',)
1583
required_version = (1, 14)
1585
verb = 'Repository.insert_stream'
1587
required_version = (1, 13)
1588
client = target._client
1589
medium = client._medium
1590
if medium._is_remote_before(required_version):
1591
# No possible way this can work.
1592
return self._insert_real(stream, src_format, resume_tokens)
1593
path = target.bzrdir._path_for_remote_call(client)
1594
if not resume_tokens:
1595
# XXX: Ugly but important for correctness, *will* be fixed during
1596
# 1.13 cycle. Pushing a stream that is interrupted results in a
1597
# fallback to the _real_repositories sink *with a partial stream*.
1598
# Thats bad because we insert less data than bzr expected. To avoid
1599
# this we do a trial push to make sure the verb is accessible, and
1600
# do not fallback when actually pushing the stream. A cleanup patch
1601
# is going to look at rewinding/restarting the stream/partial
1603
byte_stream = smart_repo._stream_to_byte_stream([], src_format)
1605
response = client.call_with_body_stream(
1606
(verb, path, '') + extra_args, byte_stream)
1607
except errors.UnknownSmartMethod:
1608
medium._remember_remote_is_before(required_version)
1609
return self._insert_real(stream, src_format, resume_tokens)
1610
byte_stream = smart_repo._stream_to_byte_stream(
1612
resume_tokens = ' '.join(resume_tokens)
1613
response = client.call_with_body_stream(
1614
(verb, path, resume_tokens) + extra_args, byte_stream)
1615
if response[0][0] not in ('ok', 'missing-basis'):
1616
raise errors.UnexpectedSmartServerResponse(response)
1617
if response[0][0] == 'missing-basis':
1618
tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1619
resume_tokens = tokens
1620
return resume_tokens, missing_keys
1622
self.target_repo.refresh_data()
1626
class RemoteStreamSource(repository.StreamSource):
1627
"""Stream data from a remote server."""
1629
def get_stream(self, search):
1630
if (self.from_repository._fallback_repositories and
1631
self.to_format._fetch_order == 'topological'):
1632
return self._real_stream(self.from_repository, search)
1633
return self.missing_parents_chain(search, [self.from_repository] +
1634
self.from_repository._fallback_repositories)
1636
def _real_stream(self, repo, search):
1637
"""Get a stream for search from repo.
1639
This never called RemoteStreamSource.get_stream, and is a heler
1640
for RemoteStreamSource._get_stream to allow getting a stream
1641
reliably whether fallback back because of old servers or trying
1642
to stream from a non-RemoteRepository (which the stacked support
1645
source = repo._get_source(self.to_format)
1646
if isinstance(source, RemoteStreamSource):
1647
return repository.StreamSource.get_stream(source, search)
1648
return source.get_stream(search)
1650
def _get_stream(self, repo, search):
1651
"""Core worker to get a stream from repo for search.
1653
This is used by both get_stream and the stacking support logic. It
1654
deliberately gets a stream for repo which does not need to be
1655
self.from_repository. In the event that repo is not Remote, or
1656
cannot do a smart stream, a fallback is made to the generic
1657
repository._get_stream() interface, via self._real_stream.
1659
In the event of stacking, streams from _get_stream will not
1660
contain all the data for search - this is normal (see get_stream).
1662
:param repo: A repository.
1663
:param search: A search.
1665
# Fallbacks may be non-smart
1666
if not isinstance(repo, RemoteRepository):
1667
return self._real_stream(repo, search)
1668
client = repo._client
1669
medium = client._medium
1670
if medium._is_remote_before((1, 13)):
1671
# streaming was added in 1.13
1672
return self._real_stream(repo, search)
1673
path = repo.bzrdir._path_for_remote_call(client)
1675
search_bytes = repo._serialise_search_result(search)
1676
response = repo._call_with_body_bytes_expecting_body(
1677
'Repository.get_stream',
1678
(path, self.to_format.network_name()), search_bytes)
1679
response_tuple, response_handler = response
1680
except errors.UnknownSmartMethod:
1681
medium._remember_remote_is_before((1,13))
1682
return self._real_stream(repo, search)
1683
if response_tuple[0] != 'ok':
1684
raise errors.UnexpectedSmartServerResponse(response_tuple)
1685
byte_stream = response_handler.read_streamed_body()
1686
src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
1687
if src_format.network_name() != repo._format.network_name():
1688
raise AssertionError(
1689
"Mismatched RemoteRepository and stream src %r, %r" % (
1690
src_format.network_name(), repo._format.network_name()))
1693
def missing_parents_chain(self, search, sources):
1694
"""Chain multiple streams together to handle stacking.
1696
:param search: The overall search to satisfy with streams.
1697
:param sources: A list of Repository objects to query.
1699
self.serialiser = self.to_format._serializer
1700
self.seen_revs = set()
1701
self.referenced_revs = set()
1702
# If there are heads in the search, or the key count is > 0, we are not
1704
while not search.is_empty() and len(sources) > 1:
1705
source = sources.pop(0)
1706
stream = self._get_stream(source, search)
1707
for kind, substream in stream:
1708
if kind != 'revisions':
1709
yield kind, substream
1711
yield kind, self.missing_parents_rev_handler(substream)
1712
search = search.refine(self.seen_revs, self.referenced_revs)
1713
self.seen_revs = set()
1714
self.referenced_revs = set()
1715
if not search.is_empty():
1716
for kind, stream in self._get_stream(sources[0], search):
1719
def missing_parents_rev_handler(self, substream):
1720
for content in substream:
1721
revision_bytes = content.get_bytes_as('fulltext')
1722
revision = self.serialiser.read_revision_from_string(revision_bytes)
1723
self.seen_revs.add(content.key[-1])
1724
self.referenced_revs.update(revision.parent_ids)
1728
class RemoteBranchLockableFiles(LockableFiles):
1729
"""A 'LockableFiles' implementation that talks to a smart server.
1731
This is not a public interface class.
1734
def __init__(self, bzrdir, _client):
1735
self.bzrdir = bzrdir
1736
self._client = _client
1737
self._need_find_modes = True
1738
LockableFiles.__init__(
1739
self, bzrdir.get_branch_transport(None),
1740
'lock', lockdir.LockDir)
1742
def _find_modes(self):
1743
# RemoteBranches don't let the client set the mode of control files.
1744
self._dir_mode = None
1745
self._file_mode = None
1748
class RemoteBranchFormat(branch.BranchFormat):
1750
def __init__(self, network_name=None):
1751
super(RemoteBranchFormat, self).__init__()
1752
self._matchingbzrdir = RemoteBzrDirFormat()
1753
self._matchingbzrdir.set_branch_format(self)
1754
self._custom_format = None
1755
self._network_name = network_name
1757
def __eq__(self, other):
1758
return (isinstance(other, RemoteBranchFormat) and
1759
self.__dict__ == other.__dict__)
1761
def _ensure_real(self):
1762
if self._custom_format is None:
1763
self._custom_format = branch.network_format_registry.get(
1766
def get_format_description(self):
1767
return 'Remote BZR Branch'
1769
def network_name(self):
1770
return self._network_name
1772
def open(self, a_bzrdir, ignore_fallbacks=False):
1773
return a_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
1775
def _vfs_initialize(self, a_bzrdir):
1776
# Initialisation when using a local bzrdir object, or a non-vfs init
1777
# method is not available on the server.
1778
# self._custom_format is always set - the start of initialize ensures
1780
if isinstance(a_bzrdir, RemoteBzrDir):
1781
a_bzrdir._ensure_real()
1782
result = self._custom_format.initialize(a_bzrdir._real_bzrdir)
1784
# We assume the bzrdir is parameterised; it may not be.
1785
result = self._custom_format.initialize(a_bzrdir)
1786
if (isinstance(a_bzrdir, RemoteBzrDir) and
1787
not isinstance(result, RemoteBranch)):
1788
result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result)
1791
def initialize(self, a_bzrdir):
1792
# 1) get the network name to use.
1793
if self._custom_format:
1794
network_name = self._custom_format.network_name()
1796
# Select the current bzrlib default and ask for that.
1797
reference_bzrdir_format = bzrdir.format_registry.get('default')()
1798
reference_format = reference_bzrdir_format.get_branch_format()
1799
self._custom_format = reference_format
1800
network_name = reference_format.network_name()
1801
# Being asked to create on a non RemoteBzrDir:
1802
if not isinstance(a_bzrdir, RemoteBzrDir):
1803
return self._vfs_initialize(a_bzrdir)
1804
medium = a_bzrdir._client._medium
1805
if medium._is_remote_before((1, 13)):
1806
return self._vfs_initialize(a_bzrdir)
1807
# Creating on a remote bzr dir.
1808
# 2) try direct creation via RPC
1809
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
1810
verb = 'BzrDir.create_branch'
1812
response = a_bzrdir._call(verb, path, network_name)
1813
except errors.UnknownSmartMethod:
1814
# Fallback - use vfs methods
1815
medium._remember_remote_is_before((1, 13))
1816
return self._vfs_initialize(a_bzrdir)
1817
if response[0] != 'ok':
1818
raise errors.UnexpectedSmartServerResponse(response)
1819
# Turn the response into a RemoteRepository object.
1820
format = RemoteBranchFormat(network_name=response[1])
1821
repo_format = response_tuple_to_repo_format(response[3:])
1822
if response[2] == '':
1823
repo_bzrdir = a_bzrdir
1825
repo_bzrdir = RemoteBzrDir(
1826
a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
1828
remote_repo = RemoteRepository(repo_bzrdir, repo_format)
1829
remote_branch = RemoteBranch(a_bzrdir, remote_repo,
1830
format=format, setup_stacking=False)
1831
# XXX: We know this is a new branch, so it must have revno 0, revid
1832
# NULL_REVISION. Creating the branch locked would make this be unable
1833
# to be wrong; here its simply very unlikely to be wrong. RBC 20090225
1834
remote_branch._last_revision_info_cache = 0, NULL_REVISION
1835
return remote_branch
1837
def make_tags(self, branch):
1839
return self._custom_format.make_tags(branch)
1841
def supports_tags(self):
1842
# Remote branches might support tags, but we won't know until we
1843
# access the real remote branch.
1845
return self._custom_format.supports_tags()
1847
def supports_stacking(self):
1849
return self._custom_format.supports_stacking()
1852
class RemoteBranch(branch.Branch, _RpcHelper):
1853
"""Branch stored on a server accessed by HPSS RPC.
1855
At the moment most operations are mapped down to simple file operations.
1858
def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
1859
_client=None, format=None, setup_stacking=True):
1860
"""Create a RemoteBranch instance.
1862
:param real_branch: An optional local implementation of the branch
1863
format, usually accessing the data via the VFS.
1864
:param _client: Private parameter for testing.
1865
:param format: A RemoteBranchFormat object, None to create one
1866
automatically. If supplied it should have a network_name already
1868
:param setup_stacking: If True make an RPC call to determine the
1869
stacked (or not) status of the branch. If False assume the branch
1872
# We intentionally don't call the parent class's __init__, because it
1873
# will try to assign to self.tags, which is a property in this subclass.
1874
# And the parent's __init__ doesn't do much anyway.
1875
self._revision_id_to_revno_cache = None
1876
self._partial_revision_id_to_revno_cache = {}
1877
self._revision_history_cache = None
1878
self._last_revision_info_cache = None
1879
self._merge_sorted_revisions_cache = None
1880
self.bzrdir = remote_bzrdir
1881
if _client is not None:
1882
self._client = _client
1884
self._client = remote_bzrdir._client
1885
self.repository = remote_repository
1886
if real_branch is not None:
1887
self._real_branch = real_branch
1888
# Give the remote repository the matching real repo.
1889
real_repo = self._real_branch.repository
1890
if isinstance(real_repo, RemoteRepository):
1891
real_repo._ensure_real()
1892
real_repo = real_repo._real_repository
1893
self.repository._set_real_repository(real_repo)
1894
# Give the branch the remote repository to let fast-pathing happen.
1895
self._real_branch.repository = self.repository
1897
self._real_branch = None
1898
# Fill out expected attributes of branch for bzrlib api users.
1899
self.base = self.bzrdir.root_transport.base
1900
self._control_files = None
1901
self._lock_mode = None
1902
self._lock_token = None
1903
self._repo_lock_token = None
1904
self._lock_count = 0
1905
self._leave_lock = False
1906
# Setup a format: note that we cannot call _ensure_real until all the
1907
# attributes above are set: This code cannot be moved higher up in this
1910
self._format = RemoteBranchFormat()
1911
if real_branch is not None:
1912
self._format._network_name = \
1913
self._real_branch._format.network_name()
1915
self._format = format
1916
if not self._format._network_name:
1917
# Did not get from open_branchV2 - old server.
1919
self._format._network_name = \
1920
self._real_branch._format.network_name()
1921
self.tags = self._format.make_tags(self)
1922
# The base class init is not called, so we duplicate this:
1923
hooks = branch.Branch.hooks['open']
1927
self._setup_stacking()
1929
def _setup_stacking(self):
1930
# configure stacking into the remote repository, by reading it from
1933
fallback_url = self.get_stacked_on_url()
1934
except (errors.NotStacked, errors.UnstackableBranchFormat,
1935
errors.UnstackableRepositoryFormat), e:
1937
# it's relative to this branch...
1938
fallback_url = urlutils.join(self.base, fallback_url)
1939
transports = [self.bzrdir.root_transport]
1940
stacked_on = branch.Branch.open(fallback_url,
1941
possible_transports=transports)
1942
self.repository.add_fallback_repository(stacked_on.repository)
1944
def _get_real_transport(self):
1945
# if we try vfs access, return the real branch's vfs transport
1947
return self._real_branch._transport
1949
_transport = property(_get_real_transport)
1952
return "%s(%s)" % (self.__class__.__name__, self.base)
1956
def _ensure_real(self):
1957
"""Ensure that there is a _real_branch set.
1959
Used before calls to self._real_branch.
1961
if self._real_branch is None:
1962
if not vfs.vfs_enabled():
1963
raise AssertionError('smart server vfs must be enabled '
1964
'to use vfs implementation')
1965
self.bzrdir._ensure_real()
1966
self._real_branch = self.bzrdir._real_bzrdir.open_branch()
1967
if self.repository._real_repository is None:
1968
# Give the remote repository the matching real repo.
1969
real_repo = self._real_branch.repository
1970
if isinstance(real_repo, RemoteRepository):
1971
real_repo._ensure_real()
1972
real_repo = real_repo._real_repository
1973
self.repository._set_real_repository(real_repo)
1974
# Give the real branch the remote repository to let fast-pathing
1976
self._real_branch.repository = self.repository
1977
if self._lock_mode == 'r':
1978
self._real_branch.lock_read()
1979
elif self._lock_mode == 'w':
1980
self._real_branch.lock_write(token=self._lock_token)
1982
def _translate_error(self, err, **context):
1983
self.repository._translate_error(err, branch=self, **context)
1985
def _clear_cached_state(self):
1986
super(RemoteBranch, self)._clear_cached_state()
1987
if self._real_branch is not None:
1988
self._real_branch._clear_cached_state()
1990
def _clear_cached_state_of_remote_branch_only(self):
1991
"""Like _clear_cached_state, but doesn't clear the cache of
1994
This is useful when falling back to calling a method of
1995
self._real_branch that changes state. In that case the underlying
1996
branch changes, so we need to invalidate this RemoteBranch's cache of
1997
it. However, there's no need to invalidate the _real_branch's cache
1998
too, in fact doing so might harm performance.
2000
super(RemoteBranch, self)._clear_cached_state()
2003
def control_files(self):
2004
# Defer actually creating RemoteBranchLockableFiles until its needed,
2005
# because it triggers an _ensure_real that we otherwise might not need.
2006
if self._control_files is None:
2007
self._control_files = RemoteBranchLockableFiles(
2008
self.bzrdir, self._client)
2009
return self._control_files
2011
def _get_checkout_format(self):
2013
return self._real_branch._get_checkout_format()
2015
def get_physical_lock_status(self):
2016
"""See Branch.get_physical_lock_status()."""
2017
# should be an API call to the server, as branches must be lockable.
2019
return self._real_branch.get_physical_lock_status()
2021
def get_stacked_on_url(self):
2022
"""Get the URL this branch is stacked against.
2024
:raises NotStacked: If the branch is not stacked.
2025
:raises UnstackableBranchFormat: If the branch does not support
2027
:raises UnstackableRepositoryFormat: If the repository does not support
2031
# there may not be a repository yet, so we can't use
2032
# self._translate_error, so we can't use self._call either.
2033
response = self._client.call('Branch.get_stacked_on_url',
2034
self._remote_path())
2035
except errors.ErrorFromSmartServer, err:
2036
# there may not be a repository yet, so we can't call through
2037
# its _translate_error
2038
_translate_error(err, branch=self)
2039
except errors.UnknownSmartMethod, err:
2041
return self._real_branch.get_stacked_on_url()
2042
if response[0] != 'ok':
2043
raise errors.UnexpectedSmartServerResponse(response)
2046
def _vfs_get_tags_bytes(self):
2048
return self._real_branch._get_tags_bytes()
2050
def _get_tags_bytes(self):
2051
medium = self._client._medium
2052
if medium._is_remote_before((1, 13)):
2053
return self._vfs_get_tags_bytes()
2055
response = self._call('Branch.get_tags_bytes', self._remote_path())
2056
except errors.UnknownSmartMethod:
2057
medium._remember_remote_is_before((1, 13))
2058
return self._vfs_get_tags_bytes()
2061
def lock_read(self):
2062
self.repository.lock_read()
2063
if not self._lock_mode:
2064
self._lock_mode = 'r'
2065
self._lock_count = 1
2066
if self._real_branch is not None:
2067
self._real_branch.lock_read()
2069
self._lock_count += 1
2071
def _remote_lock_write(self, token):
2073
branch_token = repo_token = ''
2075
branch_token = token
2076
repo_token = self.repository.lock_write()
2077
self.repository.unlock()
2078
err_context = {'token': token}
2079
response = self._call(
2080
'Branch.lock_write', self._remote_path(), branch_token,
2081
repo_token or '', **err_context)
2082
if response[0] != 'ok':
2083
raise errors.UnexpectedSmartServerResponse(response)
2084
ok, branch_token, repo_token = response
2085
return branch_token, repo_token
2087
def lock_write(self, token=None):
2088
if not self._lock_mode:
2089
# Lock the branch and repo in one remote call.
2090
remote_tokens = self._remote_lock_write(token)
2091
self._lock_token, self._repo_lock_token = remote_tokens
2092
if not self._lock_token:
2093
raise SmartProtocolError('Remote server did not return a token!')
2094
# Tell the self.repository object that it is locked.
2095
self.repository.lock_write(
2096
self._repo_lock_token, _skip_rpc=True)
2098
if self._real_branch is not None:
2099
self._real_branch.lock_write(token=self._lock_token)
2100
if token is not None:
2101
self._leave_lock = True
2103
self._leave_lock = False
2104
self._lock_mode = 'w'
2105
self._lock_count = 1
2106
elif self._lock_mode == 'r':
2107
raise errors.ReadOnlyTransaction
2109
if token is not None:
2110
# A token was given to lock_write, and we're relocking, so
2111
# check that the given token actually matches the one we
2113
if token != self._lock_token:
2114
raise errors.TokenMismatch(token, self._lock_token)
2115
self._lock_count += 1
2116
# Re-lock the repository too.
2117
self.repository.lock_write(self._repo_lock_token)
2118
return self._lock_token or None
2120
def _set_tags_bytes(self, bytes):
2122
return self._real_branch._set_tags_bytes(bytes)
2124
def _unlock(self, branch_token, repo_token):
2125
err_context = {'token': str((branch_token, repo_token))}
2126
response = self._call(
2127
'Branch.unlock', self._remote_path(), branch_token,
2128
repo_token or '', **err_context)
2129
if response == ('ok',):
2131
raise errors.UnexpectedSmartServerResponse(response)
2135
self._lock_count -= 1
2136
if not self._lock_count:
2137
self._clear_cached_state()
2138
mode = self._lock_mode
2139
self._lock_mode = None
2140
if self._real_branch is not None:
2141
if (not self._leave_lock and mode == 'w' and
2142
self._repo_lock_token):
2143
# If this RemoteBranch will remove the physical lock
2144
# for the repository, make sure the _real_branch
2145
# doesn't do it first. (Because the _real_branch's
2146
# repository is set to be the RemoteRepository.)
2147
self._real_branch.repository.leave_lock_in_place()
2148
self._real_branch.unlock()
2150
# Only write-locked branched need to make a remote method
2151
# call to perfom the unlock.
2153
if not self._lock_token:
2154
raise AssertionError('Locked, but no token!')
2155
branch_token = self._lock_token
2156
repo_token = self._repo_lock_token
2157
self._lock_token = None
2158
self._repo_lock_token = None
2159
if not self._leave_lock:
2160
self._unlock(branch_token, repo_token)
2162
self.repository.unlock()
2164
def break_lock(self):
2166
return self._real_branch.break_lock()
2168
def leave_lock_in_place(self):
2169
if not self._lock_token:
2170
raise NotImplementedError(self.leave_lock_in_place)
2171
self._leave_lock = True
2173
def dont_leave_lock_in_place(self):
2174
if not self._lock_token:
2175
raise NotImplementedError(self.dont_leave_lock_in_place)
2176
self._leave_lock = False
2178
def _last_revision_info(self):
2179
response = self._call('Branch.last_revision_info', self._remote_path())
2180
if response[0] != 'ok':
2181
raise SmartProtocolError('unexpected response code %s' % (response,))
2182
revno = int(response[1])
2183
last_revision = response[2]
2184
return (revno, last_revision)
2186
def _gen_revision_history(self):
2187
"""See Branch._gen_revision_history()."""
2188
response_tuple, response_handler = self._call_expecting_body(
2189
'Branch.revision_history', self._remote_path())
2190
if response_tuple[0] != 'ok':
2191
raise errors.UnexpectedSmartServerResponse(response_tuple)
2192
result = response_handler.read_body_bytes().split('\x00')
2197
def _remote_path(self):
2198
return self.bzrdir._path_for_remote_call(self._client)
2200
def _set_last_revision_descendant(self, revision_id, other_branch,
2201
allow_diverged=False, allow_overwrite_descendant=False):
2202
# This performs additional work to meet the hook contract; while its
2203
# undesirable, we have to synthesise the revno to call the hook, and
2204
# not calling the hook is worse as it means changes can't be prevented.
2205
# Having calculated this though, we can't just call into
2206
# set_last_revision_info as a simple call, because there is a set_rh
2207
# hook that some folk may still be using.
2208
old_revno, old_revid = self.last_revision_info()
2209
history = self._lefthand_history(revision_id)
2210
self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2211
err_context = {'other_branch': other_branch}
2212
response = self._call('Branch.set_last_revision_ex',
2213
self._remote_path(), self._lock_token, self._repo_lock_token,
2214
revision_id, int(allow_diverged), int(allow_overwrite_descendant),
2216
self._clear_cached_state()
2217
if len(response) != 3 and response[0] != 'ok':
2218
raise errors.UnexpectedSmartServerResponse(response)
2219
new_revno, new_revision_id = response[1:]
2220
self._last_revision_info_cache = new_revno, new_revision_id
2221
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2222
if self._real_branch is not None:
2223
cache = new_revno, new_revision_id
2224
self._real_branch._last_revision_info_cache = cache
2226
def _set_last_revision(self, revision_id):
2227
old_revno, old_revid = self.last_revision_info()
2228
# This performs additional work to meet the hook contract; while its
2229
# undesirable, we have to synthesise the revno to call the hook, and
2230
# not calling the hook is worse as it means changes can't be prevented.
2231
# Having calculated this though, we can't just call into
2232
# set_last_revision_info as a simple call, because there is a set_rh
2233
# hook that some folk may still be using.
2234
history = self._lefthand_history(revision_id)
2235
self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2236
self._clear_cached_state()
2237
response = self._call('Branch.set_last_revision',
2238
self._remote_path(), self._lock_token, self._repo_lock_token,
2240
if response != ('ok',):
2241
raise errors.UnexpectedSmartServerResponse(response)
2242
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2245
def set_revision_history(self, rev_history):
2246
# Send just the tip revision of the history; the server will generate
2247
# the full history from that. If the revision doesn't exist in this
2248
# branch, NoSuchRevision will be raised.
2249
if rev_history == []:
2252
rev_id = rev_history[-1]
2253
self._set_last_revision(rev_id)
2254
for hook in branch.Branch.hooks['set_rh']:
2255
hook(self, rev_history)
2256
self._cache_revision_history(rev_history)
2258
def _get_parent_location(self):
2259
medium = self._client._medium
2260
if medium._is_remote_before((1, 13)):
2261
return self._vfs_get_parent_location()
2263
response = self._call('Branch.get_parent', self._remote_path())
2264
except errors.UnknownSmartMethod:
2265
medium._remember_remote_is_before((1, 13))
2266
return self._vfs_get_parent_location()
2267
if len(response) != 1:
2268
raise errors.UnexpectedSmartServerResponse(response)
2269
parent_location = response[0]
2270
if parent_location == '':
2272
return parent_location
2274
def _vfs_get_parent_location(self):
2276
return self._real_branch._get_parent_location()
2278
def set_parent(self, url):
2280
return self._real_branch.set_parent(url)
2282
def _set_parent_location(self, url):
2283
# Used by tests, to poke bad urls into branch configurations
2285
self.set_parent(url)
2288
return self._real_branch._set_parent_location(url)
2290
def set_stacked_on_url(self, stacked_location):
2291
"""Set the URL this branch is stacked against.
2293
:raises UnstackableBranchFormat: If the branch does not support
2295
:raises UnstackableRepositoryFormat: If the repository does not support
2299
return self._real_branch.set_stacked_on_url(stacked_location)
2302
def pull(self, source, overwrite=False, stop_revision=None,
2304
self._clear_cached_state_of_remote_branch_only()
2306
return self._real_branch.pull(
2307
source, overwrite=overwrite, stop_revision=stop_revision,
2308
_override_hook_target=self, **kwargs)
2311
def push(self, target, overwrite=False, stop_revision=None):
2313
return self._real_branch.push(
2314
target, overwrite=overwrite, stop_revision=stop_revision,
2315
_override_hook_source_branch=self)
2317
def is_locked(self):
2318
return self._lock_count >= 1
2321
def revision_id_to_revno(self, revision_id):
2323
return self._real_branch.revision_id_to_revno(revision_id)
2326
def set_last_revision_info(self, revno, revision_id):
2327
# XXX: These should be returned by the set_last_revision_info verb
2328
old_revno, old_revid = self.last_revision_info()
2329
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2330
revision_id = ensure_null(revision_id)
2332
response = self._call('Branch.set_last_revision_info',
2333
self._remote_path(), self._lock_token, self._repo_lock_token,
2334
str(revno), revision_id)
2335
except errors.UnknownSmartMethod:
2337
self._clear_cached_state_of_remote_branch_only()
2338
self._real_branch.set_last_revision_info(revno, revision_id)
2339
self._last_revision_info_cache = revno, revision_id
2341
if response == ('ok',):
2342
self._clear_cached_state()
2343
self._last_revision_info_cache = revno, revision_id
2344
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2345
# Update the _real_branch's cache too.
2346
if self._real_branch is not None:
2347
cache = self._last_revision_info_cache
2348
self._real_branch._last_revision_info_cache = cache
2350
raise errors.UnexpectedSmartServerResponse(response)
2353
def generate_revision_history(self, revision_id, last_rev=None,
2355
medium = self._client._medium
2356
if not medium._is_remote_before((1, 6)):
2357
# Use a smart method for 1.6 and above servers
2359
self._set_last_revision_descendant(revision_id, other_branch,
2360
allow_diverged=True, allow_overwrite_descendant=True)
2362
except errors.UnknownSmartMethod:
2363
medium._remember_remote_is_before((1, 6))
2364
self._clear_cached_state_of_remote_branch_only()
2365
self.set_revision_history(self._lefthand_history(revision_id,
2366
last_rev=last_rev,other_branch=other_branch))
2368
def set_push_location(self, location):
2370
return self._real_branch.set_push_location(location)
2373
def _extract_tar(tar, to_dir):
2374
"""Extract all the contents of a tarfile object.
2376
A replacement for extractall, which is not present in python2.4
2379
tar.extract(tarinfo, to_dir)
2382
def _translate_error(err, **context):
2383
"""Translate an ErrorFromSmartServer into a more useful error.
2385
Possible context keys:
2393
If the error from the server doesn't match a known pattern, then
2394
UnknownErrorFromSmartServer is raised.
2398
return context[name]
2399
except KeyError, key_err:
2400
mutter('Missing key %r in context %r', key_err.args[0], context)
2403
"""Get the path from the context if present, otherwise use first error
2407
return context['path']
2408
except KeyError, key_err:
2410
return err.error_args[0]
2411
except IndexError, idx_err:
2413
'Missing key %r in context %r', key_err.args[0], context)
2416
if err.error_verb == 'NoSuchRevision':
2417
raise NoSuchRevision(find('branch'), err.error_args[0])
2418
elif err.error_verb == 'nosuchrevision':
2419
raise NoSuchRevision(find('repository'), err.error_args[0])
2420
elif err.error_tuple == ('nobranch',):
2421
raise errors.NotBranchError(path=find('bzrdir').root_transport.base)
2422
elif err.error_verb == 'norepository':
2423
raise errors.NoRepositoryPresent(find('bzrdir'))
2424
elif err.error_verb == 'LockContention':
2425
raise errors.LockContention('(remote lock)')
2426
elif err.error_verb == 'UnlockableTransport':
2427
raise errors.UnlockableTransport(find('bzrdir').root_transport)
2428
elif err.error_verb == 'LockFailed':
2429
raise errors.LockFailed(err.error_args[0], err.error_args[1])
2430
elif err.error_verb == 'TokenMismatch':
2431
raise errors.TokenMismatch(find('token'), '(remote token)')
2432
elif err.error_verb == 'Diverged':
2433
raise errors.DivergedBranches(find('branch'), find('other_branch'))
2434
elif err.error_verb == 'TipChangeRejected':
2435
raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
2436
elif err.error_verb == 'UnstackableBranchFormat':
2437
raise errors.UnstackableBranchFormat(*err.error_args)
2438
elif err.error_verb == 'UnstackableRepositoryFormat':
2439
raise errors.UnstackableRepositoryFormat(*err.error_args)
2440
elif err.error_verb == 'NotStacked':
2441
raise errors.NotStacked(branch=find('branch'))
2442
elif err.error_verb == 'PermissionDenied':
2444
if len(err.error_args) >= 2:
2445
extra = err.error_args[1]
2448
raise errors.PermissionDenied(path, extra=extra)
2449
elif err.error_verb == 'ReadError':
2451
raise errors.ReadError(path)
2452
elif err.error_verb == 'NoSuchFile':
2454
raise errors.NoSuchFile(path)
2455
elif err.error_verb == 'FileExists':
2456
raise errors.FileExists(err.error_args[0])
2457
elif err.error_verb == 'DirectoryNotEmpty':
2458
raise errors.DirectoryNotEmpty(err.error_args[0])
2459
elif err.error_verb == 'ShortReadvError':
2460
args = err.error_args
2461
raise errors.ShortReadvError(
2462
args[0], int(args[1]), int(args[2]), int(args[3]))
2463
elif err.error_verb in ('UnicodeEncodeError', 'UnicodeDecodeError'):
2464
encoding = str(err.error_args[0]) # encoding must always be a string
2465
val = err.error_args[1]
2466
start = int(err.error_args[2])
2467
end = int(err.error_args[3])
2468
reason = str(err.error_args[4]) # reason must always be a string
2469
if val.startswith('u:'):
2470
val = val[2:].decode('utf-8')
2471
elif val.startswith('s:'):
2472
val = val[2:].decode('base64')
2473
if err.error_verb == 'UnicodeDecodeError':
2474
raise UnicodeDecodeError(encoding, val, start, end, reason)
2475
elif err.error_verb == 'UnicodeEncodeError':
2476
raise UnicodeEncodeError(encoding, val, start, end, reason)
2477
elif err.error_verb == 'ReadOnlyError':
2478
raise errors.TransportNotPossible('readonly transport')
2479
raise errors.UnknownErrorFromSmartServer(err)
added
removed
bzrlib/remote.py
