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.
33
revision as _mod_revision,
37
from bzrlib.branch import BranchReferenceFormat
38
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
39
from bzrlib.decorators import needs_read_lock, needs_write_lock
40
from bzrlib.errors import (
44
from bzrlib.lockable_files import LockableFiles
45
from bzrlib.smart import client, vfs, repository as smart_repo
46
from bzrlib.revision import ensure_null, NULL_REVISION
47
from bzrlib.trace import mutter, note, warning
48
from bzrlib.util import bencode
51
class _RpcHelper(object):
52
"""Mixin class that helps with issuing RPCs."""
54
def _call(self, method, *args, **err_context):
56
return self._client.call(method, *args)
57
except errors.ErrorFromSmartServer, err:
58
self._translate_error(err, **err_context)
60
def _call_expecting_body(self, method, *args, **err_context):
62
return self._client.call_expecting_body(method, *args)
63
except errors.ErrorFromSmartServer, err:
64
self._translate_error(err, **err_context)
66
def _call_with_body_bytes_expecting_body(self, method, args, body_bytes,
69
return self._client.call_with_body_bytes_expecting_body(
70
method, args, body_bytes)
71
except errors.ErrorFromSmartServer, err:
72
self._translate_error(err, **err_context)
75
def response_tuple_to_repo_format(response):
76
"""Convert a response tuple describing a repository format to a format."""
77
format = RemoteRepositoryFormat()
78
format._rich_root_data = (response[0] == 'yes')
79
format._supports_tree_reference = (response[1] == 'yes')
80
format._supports_external_lookups = (response[2] == 'yes')
81
format._network_name = response[3]
85
# Note: RemoteBzrDirFormat is in bzrdir.py
87
class RemoteBzrDir(BzrDir, _RpcHelper):
88
"""Control directory on a remote server, accessed via bzr:// or similar."""
90
def __init__(self, transport, format, _client=None):
91
"""Construct a RemoteBzrDir.
93
:param _client: Private parameter for testing. Disables probing and the
96
BzrDir.__init__(self, transport, format)
97
# this object holds a delegated bzrdir that uses file-level operations
98
# to talk to the other side
99
self._real_bzrdir = None
100
# 1-shot cache for the call pattern 'create_branch; open_branch' - see
101
# create_branch for details.
102
self._next_open_branch_result = None
105
medium = transport.get_smart_medium()
106
self._client = client._SmartClient(medium)
108
self._client = _client
111
path = self._path_for_remote_call(self._client)
112
response = self._call('BzrDir.open', path)
113
if response not in [('yes',), ('no',)]:
114
raise errors.UnexpectedSmartServerResponse(response)
115
if response == ('no',):
116
raise errors.NotBranchError(path=transport.base)
118
def _ensure_real(self):
119
"""Ensure that there is a _real_bzrdir set.
121
Used before calls to self._real_bzrdir.
123
if not self._real_bzrdir:
124
self._real_bzrdir = BzrDir.open_from_transport(
125
self.root_transport, _server_formats=False)
126
self._format._network_name = \
127
self._real_bzrdir._format.network_name()
129
def _translate_error(self, err, **context):
130
_translate_error(err, bzrdir=self, **context)
132
def break_lock(self):
133
# Prevent aliasing problems in the next_open_branch_result cache.
134
# See create_branch for rationale.
135
self._next_open_branch_result = None
136
return BzrDir.break_lock(self)
138
def _vfs_cloning_metadir(self, require_stacking=False):
140
return self._real_bzrdir.cloning_metadir(
141
require_stacking=require_stacking)
143
def cloning_metadir(self, require_stacking=False):
144
medium = self._client._medium
145
if medium._is_remote_before((1, 13)):
146
return self._vfs_cloning_metadir(require_stacking=require_stacking)
147
verb = 'BzrDir.cloning_metadir'
152
path = self._path_for_remote_call(self._client)
154
response = self._call(verb, path, stacking)
155
except errors.UnknownSmartMethod:
156
medium._remember_remote_is_before((1, 13))
157
return self._vfs_cloning_metadir(require_stacking=require_stacking)
158
except errors.UnknownErrorFromSmartServer, err:
159
if err.error_tuple != ('BranchReference',):
161
# We need to resolve the branch reference to determine the
162
# cloning_metadir. This causes unnecessary RPCs to open the
163
# referenced branch (and bzrdir, etc) but only when the caller
164
# didn't already resolve the branch reference.
165
referenced_branch = self.open_branch()
166
return referenced_branch.bzrdir.cloning_metadir()
167
if len(response) != 3:
168
raise errors.UnexpectedSmartServerResponse(response)
169
control_name, repo_name, branch_info = response
170
if len(branch_info) != 2:
171
raise errors.UnexpectedSmartServerResponse(response)
172
branch_ref, branch_name = branch_info
173
format = bzrdir.network_format_registry.get(control_name)
175
format.repository_format = repository.network_format_registry.get(
177
if branch_ref == 'ref':
178
# XXX: we need possible_transports here to avoid reopening the
179
# connection to the referenced location
180
ref_bzrdir = BzrDir.open(branch_name)
181
branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
182
format.set_branch_format(branch_format)
183
elif branch_ref == 'branch':
185
format.set_branch_format(
186
branch.network_format_registry.get(branch_name))
188
raise errors.UnexpectedSmartServerResponse(response)
191
def create_repository(self, shared=False):
192
# as per meta1 formats - just delegate to the format object which may
194
result = self._format.repository_format.initialize(self, shared)
195
if not isinstance(result, RemoteRepository):
196
return self.open_repository()
200
def destroy_repository(self):
201
"""See BzrDir.destroy_repository"""
203
self._real_bzrdir.destroy_repository()
205
def create_branch(self):
206
# as per meta1 formats - just delegate to the format object which may
208
real_branch = self._format.get_branch_format().initialize(self)
209
if not isinstance(real_branch, RemoteBranch):
210
result = RemoteBranch(self, self.find_repository(), real_branch)
213
# BzrDir.clone_on_transport() uses the result of create_branch but does
214
# not return it to its callers; we save approximately 8% of our round
215
# trips by handing the branch we created back to the first caller to
216
# open_branch rather than probing anew. Long term we need a API in
217
# bzrdir that doesn't discard result objects (like result_branch).
219
self._next_open_branch_result = result
222
def destroy_branch(self):
223
"""See BzrDir.destroy_branch"""
225
self._real_bzrdir.destroy_branch()
226
self._next_open_branch_result = None
228
def create_workingtree(self, revision_id=None, from_branch=None):
229
raise errors.NotLocalUrl(self.transport.base)
231
def find_branch_format(self):
232
"""Find the branch 'format' for this bzrdir.
234
This might be a synthetic object for e.g. RemoteBranch and SVN.
236
b = self.open_branch()
239
def get_branch_reference(self):
240
"""See BzrDir.get_branch_reference()."""
241
response = self._get_branch_reference()
242
if response[0] == 'ref':
247
def _get_branch_reference(self):
248
path = self._path_for_remote_call(self._client)
249
medium = self._client._medium
250
if not medium._is_remote_before((1, 13)):
252
response = self._call('BzrDir.open_branchV2', path)
253
if response[0] not in ('ref', 'branch'):
254
raise errors.UnexpectedSmartServerResponse(response)
256
except errors.UnknownSmartMethod:
257
medium._remember_remote_is_before((1, 13))
258
response = self._call('BzrDir.open_branch', path)
259
if response[0] != 'ok':
260
raise errors.UnexpectedSmartServerResponse(response)
261
if response[1] != '':
262
return ('ref', response[1])
264
return ('branch', '')
266
def _get_tree_branch(self):
267
"""See BzrDir._get_tree_branch()."""
268
return None, self.open_branch()
270
def open_branch(self, _unsupported=False, ignore_fallbacks=False):
272
raise NotImplementedError('unsupported flag support not implemented yet.')
273
if self._next_open_branch_result is not None:
274
# See create_branch for details.
275
result = self._next_open_branch_result
276
self._next_open_branch_result = None
278
response = self._get_branch_reference()
279
if response[0] == 'ref':
280
# a branch reference, use the existing BranchReference logic.
281
format = BranchReferenceFormat()
282
return format.open(self, _found=True, location=response[1],
283
ignore_fallbacks=ignore_fallbacks)
284
branch_format_name = response[1]
285
if not branch_format_name:
286
branch_format_name = None
287
format = RemoteBranchFormat(network_name=branch_format_name)
288
return RemoteBranch(self, self.find_repository(), format=format,
289
setup_stacking=not ignore_fallbacks)
291
def _open_repo_v1(self, path):
292
verb = 'BzrDir.find_repository'
293
response = self._call(verb, path)
294
if response[0] != 'ok':
295
raise errors.UnexpectedSmartServerResponse(response)
296
# servers that only support the v1 method don't support external
299
repo = self._real_bzrdir.open_repository()
300
response = response + ('no', repo._format.network_name())
301
return response, repo
303
def _open_repo_v2(self, path):
304
verb = 'BzrDir.find_repositoryV2'
305
response = self._call(verb, path)
306
if response[0] != 'ok':
307
raise errors.UnexpectedSmartServerResponse(response)
309
repo = self._real_bzrdir.open_repository()
310
response = response + (repo._format.network_name(),)
311
return response, repo
313
def _open_repo_v3(self, path):
314
verb = 'BzrDir.find_repositoryV3'
315
medium = self._client._medium
316
if medium._is_remote_before((1, 13)):
317
raise errors.UnknownSmartMethod(verb)
319
response = self._call(verb, path)
320
except errors.UnknownSmartMethod:
321
medium._remember_remote_is_before((1, 13))
323
if response[0] != 'ok':
324
raise errors.UnexpectedSmartServerResponse(response)
325
return response, None
327
def open_repository(self):
328
path = self._path_for_remote_call(self._client)
330
for probe in [self._open_repo_v3, self._open_repo_v2,
333
response, real_repo = probe(path)
335
except errors.UnknownSmartMethod:
338
raise errors.UnknownSmartMethod('BzrDir.find_repository{3,2,}')
339
if response[0] != 'ok':
340
raise errors.UnexpectedSmartServerResponse(response)
341
if len(response) != 6:
342
raise SmartProtocolError('incorrect response length %s' % (response,))
343
if response[1] == '':
344
# repo is at this dir.
345
format = response_tuple_to_repo_format(response[2:])
346
# Used to support creating a real format instance when needed.
347
format._creating_bzrdir = self
348
remote_repo = RemoteRepository(self, format)
349
format._creating_repo = remote_repo
350
if real_repo is not None:
351
remote_repo._set_real_repository(real_repo)
354
raise errors.NoRepositoryPresent(self)
356
def open_workingtree(self, recommend_upgrade=True):
358
if self._real_bzrdir.has_workingtree():
359
raise errors.NotLocalUrl(self.root_transport)
361
raise errors.NoWorkingTree(self.root_transport.base)
363
def _path_for_remote_call(self, client):
364
"""Return the path to be used for this bzrdir in a remote call."""
365
return client.remote_path_from_transport(self.root_transport)
367
def get_branch_transport(self, branch_format):
369
return self._real_bzrdir.get_branch_transport(branch_format)
371
def get_repository_transport(self, repository_format):
373
return self._real_bzrdir.get_repository_transport(repository_format)
375
def get_workingtree_transport(self, workingtree_format):
377
return self._real_bzrdir.get_workingtree_transport(workingtree_format)
379
def can_convert_format(self):
380
"""Upgrading of remote bzrdirs is not supported yet."""
383
def needs_format_conversion(self, format=None):
384
"""Upgrading of remote bzrdirs is not supported yet."""
386
symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
387
% 'needs_format_conversion(format=None)')
390
def clone(self, url, revision_id=None, force_new_repo=False,
391
preserve_stacking=False):
393
return self._real_bzrdir.clone(url, revision_id=revision_id,
394
force_new_repo=force_new_repo, preserve_stacking=preserve_stacking)
396
def _get_config(self):
397
return RemoteBzrDirConfig(self)
400
class RemoteRepositoryFormat(repository.RepositoryFormat):
401
"""Format for repositories accessed over a _SmartClient.
403
Instances of this repository are represented by RemoteRepository
406
The RemoteRepositoryFormat is parameterized during construction
407
to reflect the capabilities of the real, remote format. Specifically
408
the attributes rich_root_data and supports_tree_reference are set
409
on a per instance basis, and are not set (and should not be) at
412
:ivar _custom_format: If set, a specific concrete repository format that
413
will be used when initializing a repository with this
414
RemoteRepositoryFormat.
415
:ivar _creating_repo: If set, the repository object that this
416
RemoteRepositoryFormat was created for: it can be called into
417
to obtain data like the network name.
420
_matchingbzrdir = RemoteBzrDirFormat()
423
repository.RepositoryFormat.__init__(self)
424
self._custom_format = None
425
self._network_name = None
426
self._creating_bzrdir = None
427
self._supports_external_lookups = None
428
self._supports_tree_reference = None
429
self._rich_root_data = None
432
def fast_deltas(self):
434
return self._custom_format.fast_deltas
437
def rich_root_data(self):
438
if self._rich_root_data is None:
440
self._rich_root_data = self._custom_format.rich_root_data
441
return self._rich_root_data
444
def supports_external_lookups(self):
445
if self._supports_external_lookups is None:
447
self._supports_external_lookups = \
448
self._custom_format.supports_external_lookups
449
return self._supports_external_lookups
452
def supports_tree_reference(self):
453
if self._supports_tree_reference is None:
455
self._supports_tree_reference = \
456
self._custom_format.supports_tree_reference
457
return self._supports_tree_reference
459
def _vfs_initialize(self, a_bzrdir, shared):
460
"""Helper for common code in initialize."""
461
if self._custom_format:
462
# Custom format requested
463
result = self._custom_format.initialize(a_bzrdir, shared=shared)
464
elif self._creating_bzrdir is not None:
465
# Use the format that the repository we were created to back
467
prior_repo = self._creating_bzrdir.open_repository()
468
prior_repo._ensure_real()
469
result = prior_repo._real_repository._format.initialize(
470
a_bzrdir, shared=shared)
472
# assume that a_bzr is a RemoteBzrDir but the smart server didn't
473
# support remote initialization.
474
# We delegate to a real object at this point (as RemoteBzrDir
475
# delegate to the repository format which would lead to infinite
476
# recursion if we just called a_bzrdir.create_repository.
477
a_bzrdir._ensure_real()
478
result = a_bzrdir._real_bzrdir.create_repository(shared=shared)
479
if not isinstance(result, RemoteRepository):
480
return self.open(a_bzrdir)
484
def initialize(self, a_bzrdir, shared=False):
485
# Being asked to create on a non RemoteBzrDir:
486
if not isinstance(a_bzrdir, RemoteBzrDir):
487
return self._vfs_initialize(a_bzrdir, shared)
488
medium = a_bzrdir._client._medium
489
if medium._is_remote_before((1, 13)):
490
return self._vfs_initialize(a_bzrdir, shared)
491
# Creating on a remote bzr dir.
492
# 1) get the network name to use.
493
if self._custom_format:
494
network_name = self._custom_format.network_name()
495
elif self._network_name:
496
network_name = self._network_name
498
# Select the current bzrlib default and ask for that.
499
reference_bzrdir_format = bzrdir.format_registry.get('default')()
500
reference_format = reference_bzrdir_format.repository_format
501
network_name = reference_format.network_name()
502
# 2) try direct creation via RPC
503
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
504
verb = 'BzrDir.create_repository'
510
response = a_bzrdir._call(verb, path, network_name, shared_str)
511
except errors.UnknownSmartMethod:
512
# Fallback - use vfs methods
513
medium._remember_remote_is_before((1, 13))
514
return self._vfs_initialize(a_bzrdir, shared)
516
# Turn the response into a RemoteRepository object.
517
format = response_tuple_to_repo_format(response[1:])
518
# Used to support creating a real format instance when needed.
519
format._creating_bzrdir = a_bzrdir
520
remote_repo = RemoteRepository(a_bzrdir, format)
521
format._creating_repo = remote_repo
524
def open(self, a_bzrdir):
525
if not isinstance(a_bzrdir, RemoteBzrDir):
526
raise AssertionError('%r is not a RemoteBzrDir' % (a_bzrdir,))
527
return a_bzrdir.open_repository()
529
def _ensure_real(self):
530
if self._custom_format is None:
531
self._custom_format = repository.network_format_registry.get(
535
def _fetch_order(self):
537
return self._custom_format._fetch_order
540
def _fetch_uses_deltas(self):
542
return self._custom_format._fetch_uses_deltas
545
def _fetch_reconcile(self):
547
return self._custom_format._fetch_reconcile
549
def get_format_description(self):
550
return 'bzr remote repository'
552
def __eq__(self, other):
553
return self.__class__ is other.__class__
555
def check_conversion_target(self, target_format):
556
if self.rich_root_data and not target_format.rich_root_data:
557
raise errors.BadConversionTarget(
558
'Does not support rich root data.', target_format)
559
if (self.supports_tree_reference and
560
not getattr(target_format, 'supports_tree_reference', False)):
561
raise errors.BadConversionTarget(
562
'Does not support nested trees', target_format)
564
def network_name(self):
565
if self._network_name:
566
return self._network_name
567
self._creating_repo._ensure_real()
568
return self._creating_repo._real_repository._format.network_name()
571
def _serializer(self):
573
return self._custom_format._serializer
576
class RemoteRepository(_RpcHelper):
577
"""Repository accessed over rpc.
579
For the moment most operations are performed using local transport-backed
583
def __init__(self, remote_bzrdir, format, real_repository=None, _client=None):
584
"""Create a RemoteRepository instance.
586
:param remote_bzrdir: The bzrdir hosting this repository.
587
:param format: The RemoteFormat object to use.
588
:param real_repository: If not None, a local implementation of the
589
repository logic for the repository, usually accessing the data
591
:param _client: Private testing parameter - override the smart client
592
to be used by the repository.
595
self._real_repository = real_repository
597
self._real_repository = None
598
self.bzrdir = remote_bzrdir
600
self._client = remote_bzrdir._client
602
self._client = _client
603
self._format = format
604
self._lock_mode = None
605
self._lock_token = None
607
self._leave_lock = False
608
# Cache of revision parents; misses are cached during read locks, and
609
# write locks when no _real_repository has been set.
610
self._unstacked_provider = graph.CachingParentsProvider(
611
get_parent_map=self._get_parent_map_rpc)
612
self._unstacked_provider.disable_cache()
614
# These depend on the actual remote format, so force them off for
615
# maximum compatibility. XXX: In future these should depend on the
616
# remote repository instance, but this is irrelevant until we perform
617
# reconcile via an RPC call.
618
self._reconcile_does_inventory_gc = False
619
self._reconcile_fixes_text_parents = False
620
self._reconcile_backsup_inventory = False
621
self.base = self.bzrdir.transport.base
622
# Additional places to query for data.
623
self._fallback_repositories = []
626
return "%s(%s)" % (self.__class__.__name__, self.base)
630
def abort_write_group(self, suppress_errors=False):
631
"""Complete a write group on the decorated repository.
633
Smart methods perform operations in a single step so this API
634
is not really applicable except as a compatibility thunk
635
for older plugins that don't use e.g. the CommitBuilder
638
:param suppress_errors: see Repository.abort_write_group.
641
return self._real_repository.abort_write_group(
642
suppress_errors=suppress_errors)
646
"""Decorate the real repository for now.
648
In the long term a full blown network facility is needed to avoid
649
creating a real repository object locally.
652
return self._real_repository.chk_bytes
654
def commit_write_group(self):
655
"""Complete a write group on the decorated repository.
657
Smart methods perform operations in a single step so this API
658
is not really applicable except as a compatibility thunk
659
for older plugins that don't use e.g. the CommitBuilder
663
return self._real_repository.commit_write_group()
665
def resume_write_group(self, tokens):
667
return self._real_repository.resume_write_group(tokens)
669
def suspend_write_group(self):
671
return self._real_repository.suspend_write_group()
673
def get_missing_parent_inventories(self):
675
return self._real_repository.get_missing_parent_inventories()
677
def _ensure_real(self):
678
"""Ensure that there is a _real_repository set.
680
Used before calls to self._real_repository.
682
Note that _ensure_real causes many roundtrips to the server which are
683
not desirable, and prevents the use of smart one-roundtrip RPC's to
684
perform complex operations (such as accessing parent data, streaming
685
revisions etc). Adding calls to _ensure_real should only be done when
686
bringing up new functionality, adding fallbacks for smart methods that
687
require a fallback path, and never to replace an existing smart method
688
invocation. If in doubt chat to the bzr network team.
690
if self._real_repository is None:
691
self._unstacked_provider.missing_keys.clear()
692
self.bzrdir._ensure_real()
693
self._set_real_repository(
694
self.bzrdir._real_bzrdir.open_repository())
696
def _translate_error(self, err, **context):
697
self.bzrdir._translate_error(err, repository=self, **context)
699
def find_text_key_references(self):
700
"""Find the text key references within the repository.
702
:return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
703
revision_ids. Each altered file-ids has the exact revision_ids that
704
altered it listed explicitly.
705
:return: A dictionary mapping text keys ((fileid, revision_id) tuples)
706
to whether they were referred to by the inventory of the
707
revision_id that they contain. The inventory texts from all present
708
revision ids are assessed to generate this report.
711
return self._real_repository.find_text_key_references()
713
def _generate_text_key_index(self):
714
"""Generate a new text key index for the repository.
716
This is an expensive function that will take considerable time to run.
718
:return: A dict mapping (file_id, revision_id) tuples to a list of
719
parents, also (file_id, revision_id) tuples.
722
return self._real_repository._generate_text_key_index()
724
def _get_revision_graph(self, revision_id):
725
"""Private method for using with old (< 1.2) servers to fallback."""
726
if revision_id is None:
728
elif revision.is_null(revision_id):
731
path = self.bzrdir._path_for_remote_call(self._client)
732
response = self._call_expecting_body(
733
'Repository.get_revision_graph', path, revision_id)
734
response_tuple, response_handler = response
735
if response_tuple[0] != 'ok':
736
raise errors.UnexpectedSmartServerResponse(response_tuple)
737
coded = response_handler.read_body_bytes()
739
# no revisions in this repository!
741
lines = coded.split('\n')
744
d = tuple(line.split())
745
revision_graph[d[0]] = d[1:]
747
return revision_graph
750
"""See Repository._get_sink()."""
751
return RemoteStreamSink(self)
753
def _get_source(self, to_format):
754
"""Return a source for streaming from this repository."""
755
return RemoteStreamSource(self, to_format)
758
def has_revision(self, revision_id):
759
"""True if this repository has a copy of the revision."""
760
# Copy of bzrlib.repository.Repository.has_revision
761
return revision_id in self.has_revisions((revision_id,))
764
def has_revisions(self, revision_ids):
765
"""Probe to find out the presence of multiple revisions.
767
:param revision_ids: An iterable of revision_ids.
768
:return: A set of the revision_ids that were present.
770
# Copy of bzrlib.repository.Repository.has_revisions
771
parent_map = self.get_parent_map(revision_ids)
772
result = set(parent_map)
773
if _mod_revision.NULL_REVISION in revision_ids:
774
result.add(_mod_revision.NULL_REVISION)
777
def has_same_location(self, other):
778
return (self.__class__ is other.__class__ and
779
self.bzrdir.transport.base == other.bzrdir.transport.base)
781
def get_graph(self, other_repository=None):
782
"""Return the graph for this repository format"""
783
parents_provider = self._make_parents_provider(other_repository)
784
return graph.Graph(parents_provider)
786
def gather_stats(self, revid=None, committers=None):
787
"""See Repository.gather_stats()."""
788
path = self.bzrdir._path_for_remote_call(self._client)
789
# revid can be None to indicate no revisions, not just NULL_REVISION
790
if revid is None or revision.is_null(revid):
794
if committers is None or not committers:
795
fmt_committers = 'no'
797
fmt_committers = 'yes'
798
response_tuple, response_handler = self._call_expecting_body(
799
'Repository.gather_stats', path, fmt_revid, fmt_committers)
800
if response_tuple[0] != 'ok':
801
raise errors.UnexpectedSmartServerResponse(response_tuple)
803
body = response_handler.read_body_bytes()
805
for line in body.split('\n'):
808
key, val_text = line.split(':')
809
if key in ('revisions', 'size', 'committers'):
810
result[key] = int(val_text)
811
elif key in ('firstrev', 'latestrev'):
812
values = val_text.split(' ')[1:]
813
result[key] = (float(values[0]), long(values[1]))
817
def find_branches(self, using=False):
818
"""See Repository.find_branches()."""
819
# should be an API call to the server.
821
return self._real_repository.find_branches(using=using)
823
def get_physical_lock_status(self):
824
"""See Repository.get_physical_lock_status()."""
825
# should be an API call to the server.
827
return self._real_repository.get_physical_lock_status()
829
def is_in_write_group(self):
830
"""Return True if there is an open write group.
832
write groups are only applicable locally for the smart server..
834
if self._real_repository:
835
return self._real_repository.is_in_write_group()
838
return self._lock_count >= 1
841
"""See Repository.is_shared()."""
842
path = self.bzrdir._path_for_remote_call(self._client)
843
response = self._call('Repository.is_shared', path)
844
if response[0] not in ('yes', 'no'):
845
raise SmartProtocolError('unexpected response code %s' % (response,))
846
return response[0] == 'yes'
848
def is_write_locked(self):
849
return self._lock_mode == 'w'
852
# wrong eventually - want a local lock cache context
853
if not self._lock_mode:
854
self._lock_mode = 'r'
856
self._unstacked_provider.enable_cache(cache_misses=True)
857
if self._real_repository is not None:
858
self._real_repository.lock_read()
860
self._lock_count += 1
861
for repo in self._fallback_repositories:
864
def _remote_lock_write(self, token):
865
path = self.bzrdir._path_for_remote_call(self._client)
868
err_context = {'token': token}
869
response = self._call('Repository.lock_write', path, token,
871
if response[0] == 'ok':
875
raise errors.UnexpectedSmartServerResponse(response)
877
def lock_write(self, token=None, _skip_rpc=False):
878
if not self._lock_mode:
880
if self._lock_token is not None:
881
if token != self._lock_token:
882
raise errors.TokenMismatch(token, self._lock_token)
883
self._lock_token = token
885
self._lock_token = self._remote_lock_write(token)
886
# if self._lock_token is None, then this is something like packs or
887
# svn where we don't get to lock the repo, or a weave style repository
888
# where we cannot lock it over the wire and attempts to do so will
890
if self._real_repository is not None:
891
self._real_repository.lock_write(token=self._lock_token)
892
if token is not None:
893
self._leave_lock = True
895
self._leave_lock = False
896
self._lock_mode = 'w'
898
cache_misses = self._real_repository is None
899
self._unstacked_provider.enable_cache(cache_misses=cache_misses)
900
elif self._lock_mode == 'r':
901
raise errors.ReadOnlyError(self)
903
self._lock_count += 1
904
for repo in self._fallback_repositories:
905
# Writes don't affect fallback repos
907
return self._lock_token or None
909
def leave_lock_in_place(self):
910
if not self._lock_token:
911
raise NotImplementedError(self.leave_lock_in_place)
912
self._leave_lock = True
914
def dont_leave_lock_in_place(self):
915
if not self._lock_token:
916
raise NotImplementedError(self.dont_leave_lock_in_place)
917
self._leave_lock = False
919
def _set_real_repository(self, repository):
920
"""Set the _real_repository for this repository.
922
:param repository: The repository to fallback to for non-hpss
923
implemented operations.
925
if self._real_repository is not None:
926
# Replacing an already set real repository.
927
# We cannot do this [currently] if the repository is locked -
928
# synchronised state might be lost.
930
raise AssertionError('_real_repository is already set')
931
if isinstance(repository, RemoteRepository):
932
raise AssertionError()
933
self._real_repository = repository
934
# three code paths happen here:
935
# 1) old servers, RemoteBranch.open() calls _ensure_real before setting
936
# up stacking. In this case self._fallback_repositories is [], and the
937
# real repo is already setup. Preserve the real repo and
938
# RemoteRepository.add_fallback_repository will avoid adding
940
# 2) new servers, RemoteBranch.open() sets up stacking, and when
941
# ensure_real is triggered from a branch, the real repository to
942
# set already has a matching list with separate instances, but
943
# as they are also RemoteRepositories we don't worry about making the
944
# lists be identical.
945
# 3) new servers, RemoteRepository.ensure_real is triggered before
946
# RemoteBranch.ensure real, in this case we get a repo with no fallbacks
947
# and need to populate it.
948
if (self._fallback_repositories and
949
len(self._real_repository._fallback_repositories) !=
950
len(self._fallback_repositories)):
951
if len(self._real_repository._fallback_repositories):
952
raise AssertionError(
953
"cannot cleanly remove existing _fallback_repositories")
954
for fb in self._fallback_repositories:
955
self._real_repository.add_fallback_repository(fb)
956
if self._lock_mode == 'w':
957
# if we are already locked, the real repository must be able to
958
# acquire the lock with our token.
959
self._real_repository.lock_write(self._lock_token)
960
elif self._lock_mode == 'r':
961
self._real_repository.lock_read()
963
def start_write_group(self):
964
"""Start a write group on the decorated repository.
966
Smart methods perform operations in a single step so this API
967
is not really applicable except as a compatibility thunk
968
for older plugins that don't use e.g. the CommitBuilder
972
return self._real_repository.start_write_group()
974
def _unlock(self, token):
975
path = self.bzrdir._path_for_remote_call(self._client)
977
# with no token the remote repository is not persistently locked.
979
err_context = {'token': token}
980
response = self._call('Repository.unlock', path, token,
982
if response == ('ok',):
985
raise errors.UnexpectedSmartServerResponse(response)
988
if not self._lock_count:
989
raise errors.LockNotHeld(self)
990
self._lock_count -= 1
991
if self._lock_count > 0:
993
self._unstacked_provider.disable_cache()
994
old_mode = self._lock_mode
995
self._lock_mode = None
997
# The real repository is responsible at present for raising an
998
# exception if it's in an unfinished write group. However, it
999
# normally will *not* actually remove the lock from disk - that's
1000
# done by the server on receiving the Repository.unlock call.
1001
# This is just to let the _real_repository stay up to date.
1002
if self._real_repository is not None:
1003
self._real_repository.unlock()
1005
# The rpc-level lock should be released even if there was a
1006
# problem releasing the vfs-based lock.
1008
# Only write-locked repositories need to make a remote method
1009
# call to perform the unlock.
1010
old_token = self._lock_token
1011
self._lock_token = None
1012
if not self._leave_lock:
1013
self._unlock(old_token)
1015
def break_lock(self):
1016
# should hand off to the network
1018
return self._real_repository.break_lock()
1020
def _get_tarball(self, compression):
1021
"""Return a TemporaryFile containing a repository tarball.
1023
Returns None if the server does not support sending tarballs.
1026
path = self.bzrdir._path_for_remote_call(self._client)
1028
response, protocol = self._call_expecting_body(
1029
'Repository.tarball', path, compression)
1030
except errors.UnknownSmartMethod:
1031
protocol.cancel_read_body()
1033
if response[0] == 'ok':
1034
# Extract the tarball and return it
1035
t = tempfile.NamedTemporaryFile()
1036
# TODO: rpc layer should read directly into it...
1037
t.write(protocol.read_body_bytes())
1040
raise errors.UnexpectedSmartServerResponse(response)
1042
def sprout(self, to_bzrdir, revision_id=None):
1043
# TODO: Option to control what format is created?
1045
dest_repo = self._real_repository._format.initialize(to_bzrdir,
1047
dest_repo.fetch(self, revision_id=revision_id)
1050
### These methods are just thin shims to the VFS object for now.
1052
def revision_tree(self, revision_id):
1054
return self._real_repository.revision_tree(revision_id)
1056
def get_serializer_format(self):
1058
return self._real_repository.get_serializer_format()
1060
def get_commit_builder(self, branch, parents, config, timestamp=None,
1061
timezone=None, committer=None, revprops=None,
1063
# FIXME: It ought to be possible to call this without immediately
1064
# triggering _ensure_real. For now it's the easiest thing to do.
1066
real_repo = self._real_repository
1067
builder = real_repo.get_commit_builder(branch, parents,
1068
config, timestamp=timestamp, timezone=timezone,
1069
committer=committer, revprops=revprops, revision_id=revision_id)
1072
def add_fallback_repository(self, repository):
1073
"""Add a repository to use for looking up data not held locally.
1075
:param repository: A repository.
1077
if not self._format.supports_external_lookups:
1078
raise errors.UnstackableRepositoryFormat(
1079
self._format.network_name(), self.base)
1080
# We need to accumulate additional repositories here, to pass them in
1083
self._fallback_repositories.append(repository)
1084
# If self._real_repository was parameterised already (e.g. because a
1085
# _real_branch had its get_stacked_on_url method called), then the
1086
# repository to be added may already be in the _real_repositories list.
1087
if self._real_repository is not None:
1088
fallback_locations = [repo.bzrdir.root_transport.base for repo in
1089
self._real_repository._fallback_repositories]
1090
if repository.bzrdir.root_transport.base not in fallback_locations:
1091
self._real_repository.add_fallback_repository(repository)
1093
def add_inventory(self, revid, inv, parents):
1095
return self._real_repository.add_inventory(revid, inv, parents)
1097
def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1100
return self._real_repository.add_inventory_by_delta(basis_revision_id,
1101
delta, new_revision_id, parents)
1103
def add_revision(self, rev_id, rev, inv=None, config=None):
1105
return self._real_repository.add_revision(
1106
rev_id, rev, inv=inv, config=config)
1109
def get_inventory(self, revision_id):
1111
return self._real_repository.get_inventory(revision_id)
1113
def iter_inventories(self, revision_ids):
1115
return self._real_repository.iter_inventories(revision_ids)
1118
def get_revision(self, revision_id):
1120
return self._real_repository.get_revision(revision_id)
1122
def get_transaction(self):
1124
return self._real_repository.get_transaction()
1127
def clone(self, a_bzrdir, revision_id=None):
1129
return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
1131
def make_working_trees(self):
1132
"""See Repository.make_working_trees"""
1134
return self._real_repository.make_working_trees()
1136
def refresh_data(self):
1137
"""Re-read any data needed to to synchronise with disk.
1139
This method is intended to be called after another repository instance
1140
(such as one used by a smart server) has inserted data into the
1141
repository. It may not be called during a write group, but may be
1142
called at any other time.
1144
if self.is_in_write_group():
1145
raise errors.InternalBzrError(
1146
"May not refresh_data while in a write group.")
1147
if self._real_repository is not None:
1148
self._real_repository.refresh_data()
1150
def revision_ids_to_search_result(self, result_set):
1151
"""Convert a set of revision ids to a graph SearchResult."""
1152
result_parents = set()
1153
for parents in self.get_graph().get_parent_map(
1154
result_set).itervalues():
1155
result_parents.update(parents)
1156
included_keys = result_set.intersection(result_parents)
1157
start_keys = result_set.difference(included_keys)
1158
exclude_keys = result_parents.difference(result_set)
1159
result = graph.SearchResult(start_keys, exclude_keys,
1160
len(result_set), result_set)
1164
def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1165
"""Return the revision ids that other has that this does not.
1167
These are returned in topological order.
1169
revision_id: only return revision ids included by revision_id.
1171
return repository.InterRepository.get(
1172
other, self).search_missing_revision_ids(revision_id, find_ghosts)
1174
def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
1176
# No base implementation to use as RemoteRepository is not a subclass
1177
# of Repository; so this is a copy of Repository.fetch().
1178
if fetch_spec is not None and revision_id is not None:
1179
raise AssertionError(
1180
"fetch_spec and revision_id are mutually exclusive.")
1181
if self.is_in_write_group():
1182
raise errors.InternalBzrError(
1183
"May not fetch while in a write group.")
1184
# fast path same-url fetch operations
1185
if self.has_same_location(source) and fetch_spec is None:
1186
# check that last_revision is in 'from' and then return a
1188
if (revision_id is not None and
1189
not revision.is_null(revision_id)):
1190
self.get_revision(revision_id)
1192
# if there is no specific appropriate InterRepository, this will get
1193
# the InterRepository base class, which raises an
1194
# IncompatibleRepositories when asked to fetch.
1195
inter = repository.InterRepository.get(source, self)
1196
return inter.fetch(revision_id=revision_id, pb=pb,
1197
find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1199
def create_bundle(self, target, base, fileobj, format=None):
1201
self._real_repository.create_bundle(target, base, fileobj, format)
1204
def get_ancestry(self, revision_id, topo_sorted=True):
1206
return self._real_repository.get_ancestry(revision_id, topo_sorted)
1208
def fileids_altered_by_revision_ids(self, revision_ids):
1210
return self._real_repository.fileids_altered_by_revision_ids(revision_ids)
1212
def _get_versioned_file_checker(self, revisions, revision_versions_cache):
1214
return self._real_repository._get_versioned_file_checker(
1215
revisions, revision_versions_cache)
1217
def iter_files_bytes(self, desired_files):
1218
"""See Repository.iter_file_bytes.
1221
return self._real_repository.iter_files_bytes(desired_files)
1223
def get_parent_map(self, revision_ids):
1224
"""See bzrlib.Graph.get_parent_map()."""
1225
return self._make_parents_provider().get_parent_map(revision_ids)
1227
def _get_parent_map_rpc(self, keys):
1228
"""Helper for get_parent_map that performs the RPC."""
1229
medium = self._client._medium
1230
if medium._is_remote_before((1, 2)):
1231
# We already found out that the server can't understand
1232
# Repository.get_parent_map requests, so just fetch the whole
1235
# Note that this reads the whole graph, when only some keys are
1236
# wanted. On this old server there's no way (?) to get them all
1237
# in one go, and the user probably will have seen a warning about
1238
# the server being old anyhow.
1239
rg = self._get_revision_graph(None)
1240
# There is an API discrepancy between get_parent_map and
1241
# get_revision_graph. Specifically, a "key:()" pair in
1242
# get_revision_graph just means a node has no parents. For
1243
# "get_parent_map" it means the node is a ghost. So fix up the
1244
# graph to correct this.
1245
# https://bugs.launchpad.net/bzr/+bug/214894
1246
# There is one other "bug" which is that ghosts in
1247
# get_revision_graph() are not returned at all. But we won't worry
1248
# about that for now.
1249
for node_id, parent_ids in rg.iteritems():
1250
if parent_ids == ():
1251
rg[node_id] = (NULL_REVISION,)
1252
rg[NULL_REVISION] = ()
1257
raise ValueError('get_parent_map(None) is not valid')
1258
if NULL_REVISION in keys:
1259
keys.discard(NULL_REVISION)
1260
found_parents = {NULL_REVISION:()}
1262
return found_parents
1265
# TODO(Needs analysis): We could assume that the keys being requested
1266
# from get_parent_map are in a breadth first search, so typically they
1267
# will all be depth N from some common parent, and we don't have to
1268
# have the server iterate from the root parent, but rather from the
1269
# keys we're searching; and just tell the server the keyspace we
1270
# already have; but this may be more traffic again.
1272
# Transform self._parents_map into a search request recipe.
1273
# TODO: Manage this incrementally to avoid covering the same path
1274
# repeatedly. (The server will have to on each request, but the less
1275
# work done the better).
1277
# Negative caching notes:
1278
# new server sends missing when a request including the revid
1279
# 'include-missing:' is present in the request.
1280
# missing keys are serialised as missing:X, and we then call
1281
# provider.note_missing(X) for-all X
1282
parents_map = self._unstacked_provider.get_cached_map()
1283
if parents_map is None:
1284
# Repository is not locked, so there's no cache.
1286
# start_set is all the keys in the cache
1287
start_set = set(parents_map)
1288
# result set is all the references to keys in the cache
1289
result_parents = set()
1290
for parents in parents_map.itervalues():
1291
result_parents.update(parents)
1292
stop_keys = result_parents.difference(start_set)
1293
# We don't need to send ghosts back to the server as a position to
1295
stop_keys.difference_update(self._unstacked_provider.missing_keys)
1296
key_count = len(parents_map)
1297
if (NULL_REVISION in result_parents
1298
and NULL_REVISION in self._unstacked_provider.missing_keys):
1299
# If we pruned NULL_REVISION from the stop_keys because it's also
1300
# in our cache of "missing" keys we need to increment our key count
1301
# by 1, because the reconsitituted SearchResult on the server will
1302
# still consider NULL_REVISION to be an included key.
1304
included_keys = start_set.intersection(result_parents)
1305
start_set.difference_update(included_keys)
1306
recipe = ('manual', start_set, stop_keys, key_count)
1307
body = self._serialise_search_recipe(recipe)
1308
path = self.bzrdir._path_for_remote_call(self._client)
1310
if type(key) is not str:
1312
"key %r not a plain string" % (key,))
1313
verb = 'Repository.get_parent_map'
1314
args = (path, 'include-missing:') + tuple(keys)
1316
response = self._call_with_body_bytes_expecting_body(
1318
except errors.UnknownSmartMethod:
1319
# Server does not support this method, so get the whole graph.
1320
# Worse, we have to force a disconnection, because the server now
1321
# doesn't realise it has a body on the wire to consume, so the
1322
# only way to recover is to abandon the connection.
1324
'Server is too old for fast get_parent_map, reconnecting. '
1325
'(Upgrade the server to Bazaar 1.2 to avoid this)')
1327
# To avoid having to disconnect repeatedly, we keep track of the
1328
# fact the server doesn't understand remote methods added in 1.2.
1329
medium._remember_remote_is_before((1, 2))
1330
# Recurse just once and we should use the fallback code.
1331
return self._get_parent_map_rpc(keys)
1332
response_tuple, response_handler = response
1333
if response_tuple[0] not in ['ok']:
1334
response_handler.cancel_read_body()
1335
raise errors.UnexpectedSmartServerResponse(response_tuple)
1336
if response_tuple[0] == 'ok':
1337
coded = bz2.decompress(response_handler.read_body_bytes())
1339
# no revisions found
1341
lines = coded.split('\n')
1344
d = tuple(line.split())
1346
revision_graph[d[0]] = d[1:]
1349
if d[0].startswith('missing:'):
1351
self._unstacked_provider.note_missing_key(revid)
1353
# no parents - so give the Graph result
1355
revision_graph[d[0]] = (NULL_REVISION,)
1356
return revision_graph
1359
def get_signature_text(self, revision_id):
1361
return self._real_repository.get_signature_text(revision_id)
1364
def get_inventory_xml(self, revision_id):
1366
return self._real_repository.get_inventory_xml(revision_id)
1368
def deserialise_inventory(self, revision_id, xml):
1370
return self._real_repository.deserialise_inventory(revision_id, xml)
1372
def reconcile(self, other=None, thorough=False):
1374
return self._real_repository.reconcile(other=other, thorough=thorough)
1376
def all_revision_ids(self):
1378
return self._real_repository.all_revision_ids()
1381
def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1383
return self._real_repository.get_deltas_for_revisions(revisions,
1384
specific_fileids=specific_fileids)
1387
def get_revision_delta(self, revision_id, specific_fileids=None):
1389
return self._real_repository.get_revision_delta(revision_id,
1390
specific_fileids=specific_fileids)
1393
def revision_trees(self, revision_ids):
1395
return self._real_repository.revision_trees(revision_ids)
1398
def get_revision_reconcile(self, revision_id):
1400
return self._real_repository.get_revision_reconcile(revision_id)
1403
def check(self, revision_ids=None, callback_refs=None):
1405
return self._real_repository.check(revision_ids=revision_ids,
1406
callback_refs=callback_refs)
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
target._unstacked_provider.missing_keys.clear()
1614
if target._lock_token:
1615
verb = 'Repository.insert_stream_locked'
1616
extra_args = (target._lock_token or '',)
1617
required_version = (1, 14)
1619
verb = 'Repository.insert_stream'
1621
required_version = (1, 13)
1622
client = target._client
1623
medium = client._medium
1624
if medium._is_remote_before(required_version):
1625
# No possible way this can work.
1626
return self._insert_real(stream, src_format, resume_tokens)
1627
path = target.bzrdir._path_for_remote_call(client)
1628
if not resume_tokens:
1629
# XXX: Ugly but important for correctness, *will* be fixed during
1630
# 1.13 cycle. Pushing a stream that is interrupted results in a
1631
# fallback to the _real_repositories sink *with a partial stream*.
1632
# Thats bad because we insert less data than bzr expected. To avoid
1633
# this we do a trial push to make sure the verb is accessible, and
1634
# do not fallback when actually pushing the stream. A cleanup patch
1635
# is going to look at rewinding/restarting the stream/partial
1637
byte_stream = smart_repo._stream_to_byte_stream([], src_format)
1639
response = client.call_with_body_stream(
1640
(verb, path, '') + extra_args, byte_stream)
1641
except errors.UnknownSmartMethod:
1642
medium._remember_remote_is_before(required_version)
1643
return self._insert_real(stream, src_format, resume_tokens)
1644
byte_stream = smart_repo._stream_to_byte_stream(
1646
resume_tokens = ' '.join(resume_tokens)
1647
response = client.call_with_body_stream(
1648
(verb, path, resume_tokens) + extra_args, byte_stream)
1649
if response[0][0] not in ('ok', 'missing-basis'):
1650
raise errors.UnexpectedSmartServerResponse(response)
1651
if response[0][0] == 'missing-basis':
1652
tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
1653
resume_tokens = tokens
1654
return resume_tokens, set(missing_keys)
1656
self.target_repo.refresh_data()
1660
class RemoteStreamSource(repository.StreamSource):
1661
"""Stream data from a remote server."""
1663
def get_stream(self, search):
1664
if (self.from_repository._fallback_repositories and
1665
self.to_format._fetch_order == 'topological'):
1666
return self._real_stream(self.from_repository, search)
1667
return self.missing_parents_chain(search, [self.from_repository] +
1668
self.from_repository._fallback_repositories)
1670
def _real_stream(self, repo, search):
1671
"""Get a stream for search from repo.
1673
This never called RemoteStreamSource.get_stream, and is a heler
1674
for RemoteStreamSource._get_stream to allow getting a stream
1675
reliably whether fallback back because of old servers or trying
1676
to stream from a non-RemoteRepository (which the stacked support
1679
source = repo._get_source(self.to_format)
1680
if isinstance(source, RemoteStreamSource):
1681
return repository.StreamSource.get_stream(source, search)
1682
return source.get_stream(search)
1684
def _get_stream(self, repo, search):
1685
"""Core worker to get a stream from repo for search.
1687
This is used by both get_stream and the stacking support logic. It
1688
deliberately gets a stream for repo which does not need to be
1689
self.from_repository. In the event that repo is not Remote, or
1690
cannot do a smart stream, a fallback is made to the generic
1691
repository._get_stream() interface, via self._real_stream.
1693
In the event of stacking, streams from _get_stream will not
1694
contain all the data for search - this is normal (see get_stream).
1696
:param repo: A repository.
1697
:param search: A search.
1699
# Fallbacks may be non-smart
1700
if not isinstance(repo, RemoteRepository):
1701
return self._real_stream(repo, search)
1702
client = repo._client
1703
medium = client._medium
1704
if medium._is_remote_before((1, 13)):
1705
# streaming was added in 1.13
1706
return self._real_stream(repo, search)
1707
path = repo.bzrdir._path_for_remote_call(client)
1709
search_bytes = repo._serialise_search_result(search)
1710
response = repo._call_with_body_bytes_expecting_body(
1711
'Repository.get_stream',
1712
(path, self.to_format.network_name()), search_bytes)
1713
response_tuple, response_handler = response
1714
except errors.UnknownSmartMethod:
1715
medium._remember_remote_is_before((1,13))
1716
return self._real_stream(repo, search)
1717
if response_tuple[0] != 'ok':
1718
raise errors.UnexpectedSmartServerResponse(response_tuple)
1719
byte_stream = response_handler.read_streamed_body()
1720
src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
1721
if src_format.network_name() != repo._format.network_name():
1722
raise AssertionError(
1723
"Mismatched RemoteRepository and stream src %r, %r" % (
1724
src_format.network_name(), repo._format.network_name()))
1727
def missing_parents_chain(self, search, sources):
1728
"""Chain multiple streams together to handle stacking.
1730
:param search: The overall search to satisfy with streams.
1731
:param sources: A list of Repository objects to query.
1733
self.serialiser = self.to_format._serializer
1734
self.seen_revs = set()
1735
self.referenced_revs = set()
1736
# If there are heads in the search, or the key count is > 0, we are not
1738
while not search.is_empty() and len(sources) > 1:
1739
source = sources.pop(0)
1740
stream = self._get_stream(source, search)
1741
for kind, substream in stream:
1742
if kind != 'revisions':
1743
yield kind, substream
1745
yield kind, self.missing_parents_rev_handler(substream)
1746
search = search.refine(self.seen_revs, self.referenced_revs)
1747
self.seen_revs = set()
1748
self.referenced_revs = set()
1749
if not search.is_empty():
1750
for kind, stream in self._get_stream(sources[0], search):
1753
def missing_parents_rev_handler(self, substream):
1754
for content in substream:
1755
revision_bytes = content.get_bytes_as('fulltext')
1756
revision = self.serialiser.read_revision_from_string(revision_bytes)
1757
self.seen_revs.add(content.key[-1])
1758
self.referenced_revs.update(revision.parent_ids)
1762
class RemoteBranchLockableFiles(LockableFiles):
1763
"""A 'LockableFiles' implementation that talks to a smart server.
1765
This is not a public interface class.
1768
def __init__(self, bzrdir, _client):
1769
self.bzrdir = bzrdir
1770
self._client = _client
1771
self._need_find_modes = True
1772
LockableFiles.__init__(
1773
self, bzrdir.get_branch_transport(None),
1774
'lock', lockdir.LockDir)
1776
def _find_modes(self):
1777
# RemoteBranches don't let the client set the mode of control files.
1778
self._dir_mode = None
1779
self._file_mode = None
1782
class RemoteBranchFormat(branch.BranchFormat):
1784
def __init__(self, network_name=None):
1785
super(RemoteBranchFormat, self).__init__()
1786
self._matchingbzrdir = RemoteBzrDirFormat()
1787
self._matchingbzrdir.set_branch_format(self)
1788
self._custom_format = None
1789
self._network_name = network_name
1791
def __eq__(self, other):
1792
return (isinstance(other, RemoteBranchFormat) and
1793
self.__dict__ == other.__dict__)
1795
def _ensure_real(self):
1796
if self._custom_format is None:
1797
self._custom_format = branch.network_format_registry.get(
1800
def get_format_description(self):
1801
return 'Remote BZR Branch'
1803
def network_name(self):
1804
return self._network_name
1806
def open(self, a_bzrdir, ignore_fallbacks=False):
1807
return a_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
1809
def _vfs_initialize(self, a_bzrdir):
1810
# Initialisation when using a local bzrdir object, or a non-vfs init
1811
# method is not available on the server.
1812
# self._custom_format is always set - the start of initialize ensures
1814
if isinstance(a_bzrdir, RemoteBzrDir):
1815
a_bzrdir._ensure_real()
1816
result = self._custom_format.initialize(a_bzrdir._real_bzrdir)
1818
# We assume the bzrdir is parameterised; it may not be.
1819
result = self._custom_format.initialize(a_bzrdir)
1820
if (isinstance(a_bzrdir, RemoteBzrDir) and
1821
not isinstance(result, RemoteBranch)):
1822
result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result)
1825
def initialize(self, a_bzrdir):
1826
# 1) get the network name to use.
1827
if self._custom_format:
1828
network_name = self._custom_format.network_name()
1830
# Select the current bzrlib default and ask for that.
1831
reference_bzrdir_format = bzrdir.format_registry.get('default')()
1832
reference_format = reference_bzrdir_format.get_branch_format()
1833
self._custom_format = reference_format
1834
network_name = reference_format.network_name()
1835
# Being asked to create on a non RemoteBzrDir:
1836
if not isinstance(a_bzrdir, RemoteBzrDir):
1837
return self._vfs_initialize(a_bzrdir)
1838
medium = a_bzrdir._client._medium
1839
if medium._is_remote_before((1, 13)):
1840
return self._vfs_initialize(a_bzrdir)
1841
# Creating on a remote bzr dir.
1842
# 2) try direct creation via RPC
1843
path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
1844
verb = 'BzrDir.create_branch'
1846
response = a_bzrdir._call(verb, path, network_name)
1847
except errors.UnknownSmartMethod:
1848
# Fallback - use vfs methods
1849
medium._remember_remote_is_before((1, 13))
1850
return self._vfs_initialize(a_bzrdir)
1851
if response[0] != 'ok':
1852
raise errors.UnexpectedSmartServerResponse(response)
1853
# Turn the response into a RemoteRepository object.
1854
format = RemoteBranchFormat(network_name=response[1])
1855
repo_format = response_tuple_to_repo_format(response[3:])
1856
if response[2] == '':
1857
repo_bzrdir = a_bzrdir
1859
repo_bzrdir = RemoteBzrDir(
1860
a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
1862
remote_repo = RemoteRepository(repo_bzrdir, repo_format)
1863
remote_branch = RemoteBranch(a_bzrdir, remote_repo,
1864
format=format, setup_stacking=False)
1865
# XXX: We know this is a new branch, so it must have revno 0, revid
1866
# NULL_REVISION. Creating the branch locked would make this be unable
1867
# to be wrong; here its simply very unlikely to be wrong. RBC 20090225
1868
remote_branch._last_revision_info_cache = 0, NULL_REVISION
1869
return remote_branch
1871
def make_tags(self, branch):
1873
return self._custom_format.make_tags(branch)
1875
def supports_tags(self):
1876
# Remote branches might support tags, but we won't know until we
1877
# access the real remote branch.
1879
return self._custom_format.supports_tags()
1881
def supports_stacking(self):
1883
return self._custom_format.supports_stacking()
1886
class RemoteBranch(branch.Branch, _RpcHelper):
1887
"""Branch stored on a server accessed by HPSS RPC.
1889
At the moment most operations are mapped down to simple file operations.
1892
def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
1893
_client=None, format=None, setup_stacking=True):
1894
"""Create a RemoteBranch instance.
1896
:param real_branch: An optional local implementation of the branch
1897
format, usually accessing the data via the VFS.
1898
:param _client: Private parameter for testing.
1899
:param format: A RemoteBranchFormat object, None to create one
1900
automatically. If supplied it should have a network_name already
1902
:param setup_stacking: If True make an RPC call to determine the
1903
stacked (or not) status of the branch. If False assume the branch
1906
# We intentionally don't call the parent class's __init__, because it
1907
# will try to assign to self.tags, which is a property in this subclass.
1908
# And the parent's __init__ doesn't do much anyway.
1909
self._revision_id_to_revno_cache = None
1910
self._partial_revision_id_to_revno_cache = {}
1911
self._revision_history_cache = None
1912
self._last_revision_info_cache = None
1913
self._merge_sorted_revisions_cache = None
1914
self.bzrdir = remote_bzrdir
1915
if _client is not None:
1916
self._client = _client
1918
self._client = remote_bzrdir._client
1919
self.repository = remote_repository
1920
if real_branch is not None:
1921
self._real_branch = real_branch
1922
# Give the remote repository the matching real repo.
1923
real_repo = self._real_branch.repository
1924
if isinstance(real_repo, RemoteRepository):
1925
real_repo._ensure_real()
1926
real_repo = real_repo._real_repository
1927
self.repository._set_real_repository(real_repo)
1928
# Give the branch the remote repository to let fast-pathing happen.
1929
self._real_branch.repository = self.repository
1931
self._real_branch = None
1932
# Fill out expected attributes of branch for bzrlib API users.
1933
self.base = self.bzrdir.root_transport.base
1934
self._control_files = None
1935
self._lock_mode = None
1936
self._lock_token = None
1937
self._repo_lock_token = None
1938
self._lock_count = 0
1939
self._leave_lock = False
1940
# Setup a format: note that we cannot call _ensure_real until all the
1941
# attributes above are set: This code cannot be moved higher up in this
1944
self._format = RemoteBranchFormat()
1945
if real_branch is not None:
1946
self._format._network_name = \
1947
self._real_branch._format.network_name()
1949
self._format = format
1950
if not self._format._network_name:
1951
# Did not get from open_branchV2 - old server.
1953
self._format._network_name = \
1954
self._real_branch._format.network_name()
1955
self.tags = self._format.make_tags(self)
1956
# The base class init is not called, so we duplicate this:
1957
hooks = branch.Branch.hooks['open']
1961
self._setup_stacking()
1963
def _setup_stacking(self):
1964
# configure stacking into the remote repository, by reading it from
1967
fallback_url = self.get_stacked_on_url()
1968
except (errors.NotStacked, errors.UnstackableBranchFormat,
1969
errors.UnstackableRepositoryFormat), e:
1971
self._activate_fallback_location(fallback_url, None)
1973
def _get_config(self):
1974
return RemoteBranchConfig(self)
1976
def _get_real_transport(self):
1977
# if we try vfs access, return the real branch's vfs transport
1979
return self._real_branch._transport
1981
_transport = property(_get_real_transport)
1984
return "%s(%s)" % (self.__class__.__name__, self.base)
1988
def _ensure_real(self):
1989
"""Ensure that there is a _real_branch set.
1991
Used before calls to self._real_branch.
1993
if self._real_branch is None:
1994
if not vfs.vfs_enabled():
1995
raise AssertionError('smart server vfs must be enabled '
1996
'to use vfs implementation')
1997
self.bzrdir._ensure_real()
1998
self._real_branch = self.bzrdir._real_bzrdir.open_branch()
1999
if self.repository._real_repository is None:
2000
# Give the remote repository the matching real repo.
2001
real_repo = self._real_branch.repository
2002
if isinstance(real_repo, RemoteRepository):
2003
real_repo._ensure_real()
2004
real_repo = real_repo._real_repository
2005
self.repository._set_real_repository(real_repo)
2006
# Give the real branch the remote repository to let fast-pathing
2008
self._real_branch.repository = self.repository
2009
if self._lock_mode == 'r':
2010
self._real_branch.lock_read()
2011
elif self._lock_mode == 'w':
2012
self._real_branch.lock_write(token=self._lock_token)
2014
def _translate_error(self, err, **context):
2015
self.repository._translate_error(err, branch=self, **context)
2017
def _clear_cached_state(self):
2018
super(RemoteBranch, self)._clear_cached_state()
2019
if self._real_branch is not None:
2020
self._real_branch._clear_cached_state()
2022
def _clear_cached_state_of_remote_branch_only(self):
2023
"""Like _clear_cached_state, but doesn't clear the cache of
2026
This is useful when falling back to calling a method of
2027
self._real_branch that changes state. In that case the underlying
2028
branch changes, so we need to invalidate this RemoteBranch's cache of
2029
it. However, there's no need to invalidate the _real_branch's cache
2030
too, in fact doing so might harm performance.
2032
super(RemoteBranch, self)._clear_cached_state()
2035
def control_files(self):
2036
# Defer actually creating RemoteBranchLockableFiles until its needed,
2037
# because it triggers an _ensure_real that we otherwise might not need.
2038
if self._control_files is None:
2039
self._control_files = RemoteBranchLockableFiles(
2040
self.bzrdir, self._client)
2041
return self._control_files
2043
def _get_checkout_format(self):
2045
return self._real_branch._get_checkout_format()
2047
def get_physical_lock_status(self):
2048
"""See Branch.get_physical_lock_status()."""
2049
# should be an API call to the server, as branches must be lockable.
2051
return self._real_branch.get_physical_lock_status()
2053
def get_stacked_on_url(self):
2054
"""Get the URL this branch is stacked against.
2056
:raises NotStacked: If the branch is not stacked.
2057
:raises UnstackableBranchFormat: If the branch does not support
2059
:raises UnstackableRepositoryFormat: If the repository does not support
2063
# there may not be a repository yet, so we can't use
2064
# self._translate_error, so we can't use self._call either.
2065
response = self._client.call('Branch.get_stacked_on_url',
2066
self._remote_path())
2067
except errors.ErrorFromSmartServer, err:
2068
# there may not be a repository yet, so we can't call through
2069
# its _translate_error
2070
_translate_error(err, branch=self)
2071
except errors.UnknownSmartMethod, err:
2073
return self._real_branch.get_stacked_on_url()
2074
if response[0] != 'ok':
2075
raise errors.UnexpectedSmartServerResponse(response)
2078
def _vfs_get_tags_bytes(self):
2080
return self._real_branch._get_tags_bytes()
2082
def _get_tags_bytes(self):
2083
medium = self._client._medium
2084
if medium._is_remote_before((1, 13)):
2085
return self._vfs_get_tags_bytes()
2087
response = self._call('Branch.get_tags_bytes', self._remote_path())
2088
except errors.UnknownSmartMethod:
2089
medium._remember_remote_is_before((1, 13))
2090
return self._vfs_get_tags_bytes()
2093
def lock_read(self):
2094
self.repository.lock_read()
2095
if not self._lock_mode:
2096
self._lock_mode = 'r'
2097
self._lock_count = 1
2098
if self._real_branch is not None:
2099
self._real_branch.lock_read()
2101
self._lock_count += 1
2103
def _remote_lock_write(self, token):
2105
branch_token = repo_token = ''
2107
branch_token = token
2108
repo_token = self.repository.lock_write()
2109
self.repository.unlock()
2110
err_context = {'token': token}
2111
response = self._call(
2112
'Branch.lock_write', self._remote_path(), branch_token,
2113
repo_token or '', **err_context)
2114
if response[0] != 'ok':
2115
raise errors.UnexpectedSmartServerResponse(response)
2116
ok, branch_token, repo_token = response
2117
return branch_token, repo_token
2119
def lock_write(self, token=None):
2120
if not self._lock_mode:
2121
# Lock the branch and repo in one remote call.
2122
remote_tokens = self._remote_lock_write(token)
2123
self._lock_token, self._repo_lock_token = remote_tokens
2124
if not self._lock_token:
2125
raise SmartProtocolError('Remote server did not return a token!')
2126
# Tell the self.repository object that it is locked.
2127
self.repository.lock_write(
2128
self._repo_lock_token, _skip_rpc=True)
2130
if self._real_branch is not None:
2131
self._real_branch.lock_write(token=self._lock_token)
2132
if token is not None:
2133
self._leave_lock = True
2135
self._leave_lock = False
2136
self._lock_mode = 'w'
2137
self._lock_count = 1
2138
elif self._lock_mode == 'r':
2139
raise errors.ReadOnlyTransaction
2141
if token is not None:
2142
# A token was given to lock_write, and we're relocking, so
2143
# check that the given token actually matches the one we
2145
if token != self._lock_token:
2146
raise errors.TokenMismatch(token, self._lock_token)
2147
self._lock_count += 1
2148
# Re-lock the repository too.
2149
self.repository.lock_write(self._repo_lock_token)
2150
return self._lock_token or None
2152
def _set_tags_bytes(self, bytes):
2154
return self._real_branch._set_tags_bytes(bytes)
2156
def _unlock(self, branch_token, repo_token):
2157
err_context = {'token': str((branch_token, repo_token))}
2158
response = self._call(
2159
'Branch.unlock', self._remote_path(), branch_token,
2160
repo_token or '', **err_context)
2161
if response == ('ok',):
2163
raise errors.UnexpectedSmartServerResponse(response)
2167
self._lock_count -= 1
2168
if not self._lock_count:
2169
self._clear_cached_state()
2170
mode = self._lock_mode
2171
self._lock_mode = None
2172
if self._real_branch is not None:
2173
if (not self._leave_lock and mode == 'w' and
2174
self._repo_lock_token):
2175
# If this RemoteBranch will remove the physical lock
2176
# for the repository, make sure the _real_branch
2177
# doesn't do it first. (Because the _real_branch's
2178
# repository is set to be the RemoteRepository.)
2179
self._real_branch.repository.leave_lock_in_place()
2180
self._real_branch.unlock()
2182
# Only write-locked branched need to make a remote method
2183
# call to perform the unlock.
2185
if not self._lock_token:
2186
raise AssertionError('Locked, but no token!')
2187
branch_token = self._lock_token
2188
repo_token = self._repo_lock_token
2189
self._lock_token = None
2190
self._repo_lock_token = None
2191
if not self._leave_lock:
2192
self._unlock(branch_token, repo_token)
2194
self.repository.unlock()
2196
def break_lock(self):
2198
return self._real_branch.break_lock()
2200
def leave_lock_in_place(self):
2201
if not self._lock_token:
2202
raise NotImplementedError(self.leave_lock_in_place)
2203
self._leave_lock = True
2205
def dont_leave_lock_in_place(self):
2206
if not self._lock_token:
2207
raise NotImplementedError(self.dont_leave_lock_in_place)
2208
self._leave_lock = False
2210
def _last_revision_info(self):
2211
response = self._call('Branch.last_revision_info', self._remote_path())
2212
if response[0] != 'ok':
2213
raise SmartProtocolError('unexpected response code %s' % (response,))
2214
revno = int(response[1])
2215
last_revision = response[2]
2216
return (revno, last_revision)
2218
def _gen_revision_history(self):
2219
"""See Branch._gen_revision_history()."""
2220
response_tuple, response_handler = self._call_expecting_body(
2221
'Branch.revision_history', self._remote_path())
2222
if response_tuple[0] != 'ok':
2223
raise errors.UnexpectedSmartServerResponse(response_tuple)
2224
result = response_handler.read_body_bytes().split('\x00')
2229
def _remote_path(self):
2230
return self.bzrdir._path_for_remote_call(self._client)
2232
def _set_last_revision_descendant(self, revision_id, other_branch,
2233
allow_diverged=False, allow_overwrite_descendant=False):
2234
# This performs additional work to meet the hook contract; while its
2235
# undesirable, we have to synthesise the revno to call the hook, and
2236
# not calling the hook is worse as it means changes can't be prevented.
2237
# Having calculated this though, we can't just call into
2238
# set_last_revision_info as a simple call, because there is a set_rh
2239
# hook that some folk may still be using.
2240
old_revno, old_revid = self.last_revision_info()
2241
history = self._lefthand_history(revision_id)
2242
self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2243
err_context = {'other_branch': other_branch}
2244
response = self._call('Branch.set_last_revision_ex',
2245
self._remote_path(), self._lock_token, self._repo_lock_token,
2246
revision_id, int(allow_diverged), int(allow_overwrite_descendant),
2248
self._clear_cached_state()
2249
if len(response) != 3 and response[0] != 'ok':
2250
raise errors.UnexpectedSmartServerResponse(response)
2251
new_revno, new_revision_id = response[1:]
2252
self._last_revision_info_cache = new_revno, new_revision_id
2253
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2254
if self._real_branch is not None:
2255
cache = new_revno, new_revision_id
2256
self._real_branch._last_revision_info_cache = cache
2258
def _set_last_revision(self, revision_id):
2259
old_revno, old_revid = self.last_revision_info()
2260
# This performs additional work to meet the hook contract; while its
2261
# undesirable, we have to synthesise the revno to call the hook, and
2262
# not calling the hook is worse as it means changes can't be prevented.
2263
# Having calculated this though, we can't just call into
2264
# set_last_revision_info as a simple call, because there is a set_rh
2265
# hook that some folk may still be using.
2266
history = self._lefthand_history(revision_id)
2267
self._run_pre_change_branch_tip_hooks(len(history), revision_id)
2268
self._clear_cached_state()
2269
response = self._call('Branch.set_last_revision',
2270
self._remote_path(), self._lock_token, self._repo_lock_token,
2272
if response != ('ok',):
2273
raise errors.UnexpectedSmartServerResponse(response)
2274
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2277
def set_revision_history(self, rev_history):
2278
# Send just the tip revision of the history; the server will generate
2279
# the full history from that. If the revision doesn't exist in this
2280
# branch, NoSuchRevision will be raised.
2281
if rev_history == []:
2284
rev_id = rev_history[-1]
2285
self._set_last_revision(rev_id)
2286
for hook in branch.Branch.hooks['set_rh']:
2287
hook(self, rev_history)
2288
self._cache_revision_history(rev_history)
2290
def _get_parent_location(self):
2291
medium = self._client._medium
2292
if medium._is_remote_before((1, 13)):
2293
return self._vfs_get_parent_location()
2295
response = self._call('Branch.get_parent', self._remote_path())
2296
except errors.UnknownSmartMethod:
2297
medium._remember_remote_is_before((1, 13))
2298
return self._vfs_get_parent_location()
2299
if len(response) != 1:
2300
raise errors.UnexpectedSmartServerResponse(response)
2301
parent_location = response[0]
2302
if parent_location == '':
2304
return parent_location
2306
def _vfs_get_parent_location(self):
2308
return self._real_branch._get_parent_location()
2310
def _set_parent_location(self, url):
2311
medium = self._client._medium
2312
if medium._is_remote_before((1, 15)):
2313
return self._vfs_set_parent_location(url)
2315
call_url = url or ''
2316
if type(call_url) is not str:
2317
raise AssertionError('url must be a str or None (%s)' % url)
2318
response = self._call('Branch.set_parent_location',
2319
self._remote_path(), self._lock_token, self._repo_lock_token,
2321
except errors.UnknownSmartMethod:
2322
medium._remember_remote_is_before((1, 15))
2323
return self._vfs_set_parent_location(url)
2325
raise errors.UnexpectedSmartServerResponse(response)
2327
def _vfs_set_parent_location(self, url):
2329
return self._real_branch._set_parent_location(url)
2332
def pull(self, source, overwrite=False, stop_revision=None,
2334
self._clear_cached_state_of_remote_branch_only()
2336
return self._real_branch.pull(
2337
source, overwrite=overwrite, stop_revision=stop_revision,
2338
_override_hook_target=self, **kwargs)
2341
def push(self, target, overwrite=False, stop_revision=None):
2343
return self._real_branch.push(
2344
target, overwrite=overwrite, stop_revision=stop_revision,
2345
_override_hook_source_branch=self)
2347
def is_locked(self):
2348
return self._lock_count >= 1
2351
def revision_id_to_revno(self, revision_id):
2353
return self._real_branch.revision_id_to_revno(revision_id)
2356
def set_last_revision_info(self, revno, revision_id):
2357
# XXX: These should be returned by the set_last_revision_info verb
2358
old_revno, old_revid = self.last_revision_info()
2359
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2360
revision_id = ensure_null(revision_id)
2362
response = self._call('Branch.set_last_revision_info',
2363
self._remote_path(), self._lock_token, self._repo_lock_token,
2364
str(revno), revision_id)
2365
except errors.UnknownSmartMethod:
2367
self._clear_cached_state_of_remote_branch_only()
2368
self._real_branch.set_last_revision_info(revno, revision_id)
2369
self._last_revision_info_cache = revno, revision_id
2371
if response == ('ok',):
2372
self._clear_cached_state()
2373
self._last_revision_info_cache = revno, revision_id
2374
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2375
# Update the _real_branch's cache too.
2376
if self._real_branch is not None:
2377
cache = self._last_revision_info_cache
2378
self._real_branch._last_revision_info_cache = cache
2380
raise errors.UnexpectedSmartServerResponse(response)
2383
def generate_revision_history(self, revision_id, last_rev=None,
2385
medium = self._client._medium
2386
if not medium._is_remote_before((1, 6)):
2387
# Use a smart method for 1.6 and above servers
2389
self._set_last_revision_descendant(revision_id, other_branch,
2390
allow_diverged=True, allow_overwrite_descendant=True)
2392
except errors.UnknownSmartMethod:
2393
medium._remember_remote_is_before((1, 6))
2394
self._clear_cached_state_of_remote_branch_only()
2395
self.set_revision_history(self._lefthand_history(revision_id,
2396
last_rev=last_rev,other_branch=other_branch))
2398
def set_push_location(self, location):
2400
return self._real_branch.set_push_location(location)
2403
class RemoteConfig(object):
2404
"""A Config that reads and writes from smart verbs.
2406
It is a low-level object that considers config data to be name/value pairs
2407
that may be associated with a section. Assigning meaning to the these
2408
values is done at higher levels like bzrlib.config.TreeConfig.
2411
def get_option(self, name, section=None, default=None):
2412
"""Return the value associated with a named option.
2414
:param name: The name of the value
2415
:param section: The section the option is in (if any)
2416
:param default: The value to return if the value is not set
2417
:return: The value or default value
2420
configobj = self._get_configobj()
2422
section_obj = configobj
2425
section_obj = configobj[section]
2428
return section_obj.get(name, default)
2429
except errors.UnknownSmartMethod:
2430
return self._vfs_get_option(name, section, default)
2432
def _response_to_configobj(self, response):
2433
if len(response[0]) and response[0][0] != 'ok':
2434
raise errors.UnexpectedSmartServerResponse(response)
2435
lines = response[1].read_body_bytes().splitlines()
2436
return config.ConfigObj(lines, encoding='utf-8')
2439
class RemoteBranchConfig(RemoteConfig):
2440
"""A RemoteConfig for Branches."""
2442
def __init__(self, branch):
2443
self._branch = branch
2445
def _get_configobj(self):
2446
path = self._branch._remote_path()
2447
response = self._branch._client.call_expecting_body(
2448
'Branch.get_config_file', path)
2449
return self._response_to_configobj(response)
2451
def set_option(self, value, name, section=None):
2452
"""Set the value associated with a named option.
2454
:param value: The value to set
2455
:param name: The name of the value to set
2456
:param section: The section the option is in (if any)
2458
medium = self._branch._client._medium
2459
if medium._is_remote_before((1, 14)):
2460
return self._vfs_set_option(value, name, section)
2462
path = self._branch._remote_path()
2463
response = self._branch._client.call('Branch.set_config_option',
2464
path, self._branch._lock_token, self._branch._repo_lock_token,
2465
value.encode('utf8'), name, section or '')
2466
except errors.UnknownSmartMethod:
2467
medium._remember_remote_is_before((1, 14))
2468
return self._vfs_set_option(value, name, section)
2470
raise errors.UnexpectedSmartServerResponse(response)
2472
def _real_object(self):
2473
self._branch._ensure_real()
2474
return self._branch._real_branch
2476
def _vfs_set_option(self, value, name, section=None):
2477
return self._real_object()._get_config().set_option(
2478
value, name, section)
2481
class RemoteBzrDirConfig(RemoteConfig):
2482
"""A RemoteConfig for BzrDirs."""
2484
def __init__(self, bzrdir):
2485
self._bzrdir = bzrdir
2487
def _get_configobj(self):
2488
medium = self._bzrdir._client._medium
2489
verb = 'BzrDir.get_config_file'
2490
if medium._is_remote_before((1, 15)):
2491
raise errors.UnknownSmartMethod(verb)
2492
path = self._bzrdir._path_for_remote_call(self._bzrdir._client)
2493
response = self._bzrdir._call_expecting_body(
2495
return self._response_to_configobj(response)
2497
def _vfs_get_option(self, name, section, default):
2498
return self._real_object()._get_config().get_option(
2499
name, section, default)
2501
def set_option(self, value, name, section=None):
2502
"""Set the value associated with a named option.
2504
:param value: The value to set
2505
:param name: The name of the value to set
2506
:param section: The section the option is in (if any)
2508
return self._real_object()._get_config().set_option(
2509
value, name, section)
2511
def _real_object(self):
2512
self._bzrdir._ensure_real()
2513
return self._bzrdir._real_bzrdir
2517
def _extract_tar(tar, to_dir):
2518
"""Extract all the contents of a tarfile object.
2520
A replacement for extractall, which is not present in python2.4
2523
tar.extract(tarinfo, to_dir)
2526
def _translate_error(err, **context):
2527
"""Translate an ErrorFromSmartServer into a more useful error.
2529
Possible context keys:
2537
If the error from the server doesn't match a known pattern, then
2538
UnknownErrorFromSmartServer is raised.
2542
return context[name]
2543
except KeyError, key_err:
2544
mutter('Missing key %r in context %r', key_err.args[0], context)
2547
"""Get the path from the context if present, otherwise use first error
2551
return context['path']
2552
except KeyError, key_err:
2554
return err.error_args[0]
2555
except IndexError, idx_err:
2557
'Missing key %r in context %r', key_err.args[0], context)
2560
if err.error_verb == 'NoSuchRevision':
2561
raise NoSuchRevision(find('branch'), err.error_args[0])
2562
elif err.error_verb == 'nosuchrevision':
2563
raise NoSuchRevision(find('repository'), err.error_args[0])
2564
elif err.error_tuple == ('nobranch',):
2565
raise errors.NotBranchError(path=find('bzrdir').root_transport.base)
2566
elif err.error_verb == 'norepository':
2567
raise errors.NoRepositoryPresent(find('bzrdir'))
2568
elif err.error_verb == 'LockContention':
2569
raise errors.LockContention('(remote lock)')
2570
elif err.error_verb == 'UnlockableTransport':
2571
raise errors.UnlockableTransport(find('bzrdir').root_transport)
2572
elif err.error_verb == 'LockFailed':
2573
raise errors.LockFailed(err.error_args[0], err.error_args[1])
2574
elif err.error_verb == 'TokenMismatch':
2575
raise errors.TokenMismatch(find('token'), '(remote token)')
2576
elif err.error_verb == 'Diverged':
2577
raise errors.DivergedBranches(find('branch'), find('other_branch'))
2578
elif err.error_verb == 'TipChangeRejected':
2579
raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
2580
elif err.error_verb == 'UnstackableBranchFormat':
2581
raise errors.UnstackableBranchFormat(*err.error_args)
2582
elif err.error_verb == 'UnstackableRepositoryFormat':
2583
raise errors.UnstackableRepositoryFormat(*err.error_args)
2584
elif err.error_verb == 'NotStacked':
2585
raise errors.NotStacked(branch=find('branch'))
2586
elif err.error_verb == 'PermissionDenied':
2588
if len(err.error_args) >= 2:
2589
extra = err.error_args[1]
2592
raise errors.PermissionDenied(path, extra=extra)
2593
elif err.error_verb == 'ReadError':
2595
raise errors.ReadError(path)
2596
elif err.error_verb == 'NoSuchFile':
2598
raise errors.NoSuchFile(path)
2599
elif err.error_verb == 'FileExists':
2600
raise errors.FileExists(err.error_args[0])
2601
elif err.error_verb == 'DirectoryNotEmpty':
2602
raise errors.DirectoryNotEmpty(err.error_args[0])
2603
elif err.error_verb == 'ShortReadvError':
2604
args = err.error_args
2605
raise errors.ShortReadvError(
2606
args[0], int(args[1]), int(args[2]), int(args[3]))
2607
elif err.error_verb in ('UnicodeEncodeError', 'UnicodeDecodeError'):
2608
encoding = str(err.error_args[0]) # encoding must always be a string
2609
val = err.error_args[1]
2610
start = int(err.error_args[2])
2611
end = int(err.error_args[3])
2612
reason = str(err.error_args[4]) # reason must always be a string
2613
if val.startswith('u:'):
2614
val = val[2:].decode('utf-8')
2615
elif val.startswith('s:'):
2616
val = val[2:].decode('base64')
2617
if err.error_verb == 'UnicodeDecodeError':
2618
raise UnicodeDecodeError(encoding, val, start, end, reason)
2619
elif err.error_verb == 'UnicodeEncodeError':
2620
raise UnicodeEncodeError(encoding, val, start, end, reason)
2621
elif err.error_verb == 'ReadOnlyError':
2622
raise errors.TransportNotPossible('readonly transport')
2623
raise errors.UnknownErrorFromSmartServer(err)
added
removed
bzrlib/remote.py
