~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: Martin Pool
  • Date: 2009-11-16 02:26:32 UTC
  • mto: This revision was merged to the branch mainline in revision 4880.
  • Revision ID: mbp@sourcefrog.net-20091116022632-261trs2osy8oupe3
Convert version-info to use TextUIOutputStream

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2006, 2007, 2008, 2009 Canonical Ltd
 
2
#
 
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.
 
7
#
 
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.
 
12
#
 
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
 
16
 
 
17
import bz2
 
18
 
 
19
from bzrlib import (
 
20
    bencode,
 
21
    branch,
 
22
    bzrdir,
 
23
    config,
 
24
    debug,
 
25
    errors,
 
26
    graph,
 
27
    lock,
 
28
    lockdir,
 
29
    repository,
 
30
    revision,
 
31
    revision as _mod_revision,
 
32
    symbol_versioning,
 
33
)
 
34
from bzrlib.branch import BranchReferenceFormat
 
35
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
 
36
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
 
37
from bzrlib.errors import (
 
38
    NoSuchRevision,
 
39
    SmartProtocolError,
 
40
    )
 
41
from bzrlib.lockable_files import LockableFiles
 
42
from bzrlib.smart import client, vfs, repository as smart_repo
 
43
from bzrlib.revision import ensure_null, NULL_REVISION
 
44
from bzrlib.trace import mutter, note, warning
 
45
 
 
46
 
 
47
class _RpcHelper(object):
 
48
    """Mixin class that helps with issuing RPCs."""
 
49
 
 
50
    def _call(self, method, *args, **err_context):
 
51
        try:
 
52
            return self._client.call(method, *args)
 
53
        except errors.ErrorFromSmartServer, err:
 
54
            self._translate_error(err, **err_context)
 
55
 
 
56
    def _call_expecting_body(self, method, *args, **err_context):
 
57
        try:
 
58
            return self._client.call_expecting_body(method, *args)
 
59
        except errors.ErrorFromSmartServer, err:
 
60
            self._translate_error(err, **err_context)
 
61
 
 
62
    def _call_with_body_bytes(self, method, args, body_bytes, **err_context):
 
63
        try:
 
64
            return self._client.call_with_body_bytes(method, args, body_bytes)
 
65
        except errors.ErrorFromSmartServer, err:
 
66
            self._translate_error(err, **err_context)
 
67
 
 
68
    def _call_with_body_bytes_expecting_body(self, method, args, body_bytes,
 
69
                                             **err_context):
 
70
        try:
 
71
            return self._client.call_with_body_bytes_expecting_body(
 
72
                method, args, body_bytes)
 
73
        except errors.ErrorFromSmartServer, err:
 
74
            self._translate_error(err, **err_context)
 
75
 
 
76
 
 
77
def response_tuple_to_repo_format(response):
 
78
    """Convert a response tuple describing a repository format to a format."""
 
79
    format = RemoteRepositoryFormat()
 
80
    format._rich_root_data = (response[0] == 'yes')
 
81
    format._supports_tree_reference = (response[1] == 'yes')
 
82
    format._supports_external_lookups = (response[2] == 'yes')
 
83
    format._network_name = response[3]
 
84
    return format
 
85
 
 
86
 
 
87
# Note: RemoteBzrDirFormat is in bzrdir.py
 
88
 
 
89
class RemoteBzrDir(BzrDir, _RpcHelper):
 
90
    """Control directory on a remote server, accessed via bzr:// or similar."""
 
91
 
 
92
    def __init__(self, transport, format, _client=None, _force_probe=False):
 
93
        """Construct a RemoteBzrDir.
 
94
 
 
95
        :param _client: Private parameter for testing. Disables probing and the
 
96
            use of a real bzrdir.
 
97
        """
 
98
        BzrDir.__init__(self, transport, format)
 
99
        # this object holds a delegated bzrdir that uses file-level operations
 
100
        # to talk to the other side
 
101
        self._real_bzrdir = None
 
102
        self._has_working_tree = None
 
103
        # 1-shot cache for the call pattern 'create_branch; open_branch' - see
 
104
        # create_branch for details.
 
105
        self._next_open_branch_result = None
 
106
 
 
107
        if _client is None:
 
108
            medium = transport.get_smart_medium()
 
109
            self._client = client._SmartClient(medium)
 
110
        else:
 
111
            self._client = _client
 
112
            if not _force_probe:
 
113
                return
 
114
 
 
115
        self._probe_bzrdir()
 
116
 
 
117
    def _probe_bzrdir(self):
 
118
        medium = self._client._medium
 
119
        path = self._path_for_remote_call(self._client)
 
120
        if medium._is_remote_before((2, 1)):
 
121
            self._rpc_open(path)
 
122
            return
 
123
        try:
 
124
            self._rpc_open_2_1(path)
 
125
            return
 
126
        except errors.UnknownSmartMethod:
 
127
            medium._remember_remote_is_before((2, 1))
 
128
            self._rpc_open(path)
 
129
 
 
130
    def _rpc_open_2_1(self, path):
 
131
        response = self._call('BzrDir.open_2.1', path)
 
132
        if response == ('no',):
 
133
            raise errors.NotBranchError(path=self.root_transport.base)
 
134
        elif response[0] == 'yes':
 
135
            if response[1] == 'yes':
 
136
                self._has_working_tree = True
 
137
            elif response[1] == 'no':
 
138
                self._has_working_tree = False
 
139
            else:
 
140
                raise errors.UnexpectedSmartServerResponse(response)
 
141
        else:
 
142
            raise errors.UnexpectedSmartServerResponse(response)
 
143
 
 
144
    def _rpc_open(self, path):
 
145
        response = self._call('BzrDir.open', path)
 
146
        if response not in [('yes',), ('no',)]:
 
147
            raise errors.UnexpectedSmartServerResponse(response)
 
148
        if response == ('no',):
 
149
            raise errors.NotBranchError(path=self.root_transport.base)
 
150
 
 
151
    def _ensure_real(self):
 
152
        """Ensure that there is a _real_bzrdir set.
 
153
 
 
154
        Used before calls to self._real_bzrdir.
 
155
        """
 
156
        if not self._real_bzrdir:
 
157
            if 'hpssvfs' in debug.debug_flags:
 
158
                import traceback
 
159
                warning('VFS BzrDir access triggered\n%s',
 
160
                    ''.join(traceback.format_stack()))
 
161
            self._real_bzrdir = BzrDir.open_from_transport(
 
162
                self.root_transport, _server_formats=False)
 
163
            self._format._network_name = \
 
164
                self._real_bzrdir._format.network_name()
 
165
 
 
166
    def _translate_error(self, err, **context):
 
167
        _translate_error(err, bzrdir=self, **context)
 
168
 
 
169
    def break_lock(self):
 
170
        # Prevent aliasing problems in the next_open_branch_result cache.
 
171
        # See create_branch for rationale.
 
172
        self._next_open_branch_result = None
 
173
        return BzrDir.break_lock(self)
 
174
 
 
175
    def _vfs_cloning_metadir(self, require_stacking=False):
 
176
        self._ensure_real()
 
177
        return self._real_bzrdir.cloning_metadir(
 
178
            require_stacking=require_stacking)
 
179
 
 
180
    def cloning_metadir(self, require_stacking=False):
 
181
        medium = self._client._medium
 
182
        if medium._is_remote_before((1, 13)):
 
183
            return self._vfs_cloning_metadir(require_stacking=require_stacking)
 
184
        verb = 'BzrDir.cloning_metadir'
 
185
        if require_stacking:
 
186
            stacking = 'True'
 
187
        else:
 
188
            stacking = 'False'
 
189
        path = self._path_for_remote_call(self._client)
 
190
        try:
 
191
            response = self._call(verb, path, stacking)
 
192
        except errors.UnknownSmartMethod:
 
193
            medium._remember_remote_is_before((1, 13))
 
194
            return self._vfs_cloning_metadir(require_stacking=require_stacking)
 
195
        except errors.UnknownErrorFromSmartServer, err:
 
196
            if err.error_tuple != ('BranchReference',):
 
197
                raise
 
198
            # We need to resolve the branch reference to determine the
 
199
            # cloning_metadir.  This causes unnecessary RPCs to open the
 
200
            # referenced branch (and bzrdir, etc) but only when the caller
 
201
            # didn't already resolve the branch reference.
 
202
            referenced_branch = self.open_branch()
 
203
            return referenced_branch.bzrdir.cloning_metadir()
 
204
        if len(response) != 3:
 
205
            raise errors.UnexpectedSmartServerResponse(response)
 
206
        control_name, repo_name, branch_info = response
 
207
        if len(branch_info) != 2:
 
208
            raise errors.UnexpectedSmartServerResponse(response)
 
209
        branch_ref, branch_name = branch_info
 
210
        format = bzrdir.network_format_registry.get(control_name)
 
211
        if repo_name:
 
212
            format.repository_format = repository.network_format_registry.get(
 
213
                repo_name)
 
214
        if branch_ref == 'ref':
 
215
            # XXX: we need possible_transports here to avoid reopening the
 
216
            # connection to the referenced location
 
217
            ref_bzrdir = BzrDir.open(branch_name)
 
218
            branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
 
219
            format.set_branch_format(branch_format)
 
220
        elif branch_ref == 'branch':
 
221
            if branch_name:
 
222
                format.set_branch_format(
 
223
                    branch.network_format_registry.get(branch_name))
 
224
        else:
 
225
            raise errors.UnexpectedSmartServerResponse(response)
 
226
        return format
 
227
 
 
228
    def create_repository(self, shared=False):
 
229
        # as per meta1 formats - just delegate to the format object which may
 
230
        # be parameterised.
 
231
        result = self._format.repository_format.initialize(self, shared)
 
232
        if not isinstance(result, RemoteRepository):
 
233
            return self.open_repository()
 
234
        else:
 
235
            return result
 
236
 
 
237
    def destroy_repository(self):
 
238
        """See BzrDir.destroy_repository"""
 
239
        self._ensure_real()
 
240
        self._real_bzrdir.destroy_repository()
 
241
 
 
242
    def create_branch(self):
 
243
        # as per meta1 formats - just delegate to the format object which may
 
244
        # be parameterised.
 
245
        real_branch = self._format.get_branch_format().initialize(self)
 
246
        if not isinstance(real_branch, RemoteBranch):
 
247
            result = RemoteBranch(self, self.find_repository(), real_branch)
 
248
        else:
 
249
            result = real_branch
 
250
        # BzrDir.clone_on_transport() uses the result of create_branch but does
 
251
        # not return it to its callers; we save approximately 8% of our round
 
252
        # trips by handing the branch we created back to the first caller to
 
253
        # open_branch rather than probing anew. Long term we need a API in
 
254
        # bzrdir that doesn't discard result objects (like result_branch).
 
255
        # RBC 20090225
 
256
        self._next_open_branch_result = result
 
257
        return result
 
258
 
 
259
    def destroy_branch(self):
 
260
        """See BzrDir.destroy_branch"""
 
261
        self._ensure_real()
 
262
        self._real_bzrdir.destroy_branch()
 
263
        self._next_open_branch_result = None
 
264
 
 
265
    def create_workingtree(self, revision_id=None, from_branch=None):
 
266
        raise errors.NotLocalUrl(self.transport.base)
 
267
 
 
268
    def find_branch_format(self):
 
269
        """Find the branch 'format' for this bzrdir.
 
270
 
 
271
        This might be a synthetic object for e.g. RemoteBranch and SVN.
 
272
        """
 
273
        b = self.open_branch()
 
274
        return b._format
 
275
 
 
276
    def get_branch_reference(self):
 
277
        """See BzrDir.get_branch_reference()."""
 
278
        response = self._get_branch_reference()
 
279
        if response[0] == 'ref':
 
280
            return response[1]
 
281
        else:
 
282
            return None
 
283
 
 
284
    def _get_branch_reference(self):
 
285
        path = self._path_for_remote_call(self._client)
 
286
        medium = self._client._medium
 
287
        if not medium._is_remote_before((1, 13)):
 
288
            try:
 
289
                response = self._call('BzrDir.open_branchV2', path)
 
290
                if response[0] not in ('ref', 'branch'):
 
291
                    raise errors.UnexpectedSmartServerResponse(response)
 
292
                return response
 
293
            except errors.UnknownSmartMethod:
 
294
                medium._remember_remote_is_before((1, 13))
 
295
        response = self._call('BzrDir.open_branch', path)
 
296
        if response[0] != 'ok':
 
297
            raise errors.UnexpectedSmartServerResponse(response)
 
298
        if response[1] != '':
 
299
            return ('ref', response[1])
 
300
        else:
 
301
            return ('branch', '')
 
302
 
 
303
    def _get_tree_branch(self):
 
304
        """See BzrDir._get_tree_branch()."""
 
305
        return None, self.open_branch()
 
306
 
 
307
    def open_branch(self, _unsupported=False, ignore_fallbacks=False):
 
308
        if _unsupported:
 
309
            raise NotImplementedError('unsupported flag support not implemented yet.')
 
310
        if self._next_open_branch_result is not None:
 
311
            # See create_branch for details.
 
312
            result = self._next_open_branch_result
 
313
            self._next_open_branch_result = None
 
314
            return result
 
315
        response = self._get_branch_reference()
 
316
        if response[0] == 'ref':
 
317
            # a branch reference, use the existing BranchReference logic.
 
318
            format = BranchReferenceFormat()
 
319
            return format.open(self, _found=True, location=response[1],
 
320
                ignore_fallbacks=ignore_fallbacks)
 
321
        branch_format_name = response[1]
 
322
        if not branch_format_name:
 
323
            branch_format_name = None
 
324
        format = RemoteBranchFormat(network_name=branch_format_name)
 
325
        return RemoteBranch(self, self.find_repository(), format=format,
 
326
            setup_stacking=not ignore_fallbacks)
 
327
 
 
328
    def _open_repo_v1(self, path):
 
329
        verb = 'BzrDir.find_repository'
 
330
        response = self._call(verb, path)
 
331
        if response[0] != 'ok':
 
332
            raise errors.UnexpectedSmartServerResponse(response)
 
333
        # servers that only support the v1 method don't support external
 
334
        # references either.
 
335
        self._ensure_real()
 
336
        repo = self._real_bzrdir.open_repository()
 
337
        response = response + ('no', repo._format.network_name())
 
338
        return response, repo
 
339
 
 
340
    def _open_repo_v2(self, path):
 
341
        verb = 'BzrDir.find_repositoryV2'
 
342
        response = self._call(verb, path)
 
343
        if response[0] != 'ok':
 
344
            raise errors.UnexpectedSmartServerResponse(response)
 
345
        self._ensure_real()
 
346
        repo = self._real_bzrdir.open_repository()
 
347
        response = response + (repo._format.network_name(),)
 
348
        return response, repo
 
349
 
 
350
    def _open_repo_v3(self, path):
 
351
        verb = 'BzrDir.find_repositoryV3'
 
352
        medium = self._client._medium
 
353
        if medium._is_remote_before((1, 13)):
 
354
            raise errors.UnknownSmartMethod(verb)
 
355
        try:
 
356
            response = self._call(verb, path)
 
357
        except errors.UnknownSmartMethod:
 
358
            medium._remember_remote_is_before((1, 13))
 
359
            raise
 
360
        if response[0] != 'ok':
 
361
            raise errors.UnexpectedSmartServerResponse(response)
 
362
        return response, None
 
363
 
 
364
    def open_repository(self):
 
365
        path = self._path_for_remote_call(self._client)
 
366
        response = None
 
367
        for probe in [self._open_repo_v3, self._open_repo_v2,
 
368
            self._open_repo_v1]:
 
369
            try:
 
370
                response, real_repo = probe(path)
 
371
                break
 
372
            except errors.UnknownSmartMethod:
 
373
                pass
 
374
        if response is None:
 
375
            raise errors.UnknownSmartMethod('BzrDir.find_repository{3,2,}')
 
376
        if response[0] != 'ok':
 
377
            raise errors.UnexpectedSmartServerResponse(response)
 
378
        if len(response) != 6:
 
379
            raise SmartProtocolError('incorrect response length %s' % (response,))
 
380
        if response[1] == '':
 
381
            # repo is at this dir.
 
382
            format = response_tuple_to_repo_format(response[2:])
 
383
            # Used to support creating a real format instance when needed.
 
384
            format._creating_bzrdir = self
 
385
            remote_repo = RemoteRepository(self, format)
 
386
            format._creating_repo = remote_repo
 
387
            if real_repo is not None:
 
388
                remote_repo._set_real_repository(real_repo)
 
389
            return remote_repo
 
390
        else:
 
391
            raise errors.NoRepositoryPresent(self)
 
392
 
 
393
    def has_workingtree(self):
 
394
        if self._has_working_tree is None:
 
395
            self._ensure_real()
 
396
            self._has_working_tree = self._real_bzrdir.has_workingtree()
 
397
        return self._has_working_tree
 
398
 
 
399
    def open_workingtree(self, recommend_upgrade=True):
 
400
        if self.has_workingtree():
 
401
            raise errors.NotLocalUrl(self.root_transport)
 
402
        else:
 
403
            raise errors.NoWorkingTree(self.root_transport.base)
 
404
 
 
405
    def _path_for_remote_call(self, client):
 
406
        """Return the path to be used for this bzrdir in a remote call."""
 
407
        return client.remote_path_from_transport(self.root_transport)
 
408
 
 
409
    def get_branch_transport(self, branch_format):
 
410
        self._ensure_real()
 
411
        return self._real_bzrdir.get_branch_transport(branch_format)
 
412
 
 
413
    def get_repository_transport(self, repository_format):
 
414
        self._ensure_real()
 
415
        return self._real_bzrdir.get_repository_transport(repository_format)
 
416
 
 
417
    def get_workingtree_transport(self, workingtree_format):
 
418
        self._ensure_real()
 
419
        return self._real_bzrdir.get_workingtree_transport(workingtree_format)
 
420
 
 
421
    def can_convert_format(self):
 
422
        """Upgrading of remote bzrdirs is not supported yet."""
 
423
        return False
 
424
 
 
425
    def needs_format_conversion(self, format=None):
 
426
        """Upgrading of remote bzrdirs is not supported yet."""
 
427
        if format is None:
 
428
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
 
429
                % 'needs_format_conversion(format=None)')
 
430
        return False
 
431
 
 
432
    def clone(self, url, revision_id=None, force_new_repo=False,
 
433
              preserve_stacking=False):
 
434
        self._ensure_real()
 
435
        return self._real_bzrdir.clone(url, revision_id=revision_id,
 
436
            force_new_repo=force_new_repo, preserve_stacking=preserve_stacking)
 
437
 
 
438
    def _get_config(self):
 
439
        return RemoteBzrDirConfig(self)
 
440
 
 
441
 
 
442
class RemoteRepositoryFormat(repository.RepositoryFormat):
 
443
    """Format for repositories accessed over a _SmartClient.
 
444
 
 
445
    Instances of this repository are represented by RemoteRepository
 
446
    instances.
 
447
 
 
448
    The RemoteRepositoryFormat is parameterized during construction
 
449
    to reflect the capabilities of the real, remote format. Specifically
 
450
    the attributes rich_root_data and supports_tree_reference are set
 
451
    on a per instance basis, and are not set (and should not be) at
 
452
    the class level.
 
453
 
 
454
    :ivar _custom_format: If set, a specific concrete repository format that
 
455
        will be used when initializing a repository with this
 
456
        RemoteRepositoryFormat.
 
457
    :ivar _creating_repo: If set, the repository object that this
 
458
        RemoteRepositoryFormat was created for: it can be called into
 
459
        to obtain data like the network name.
 
460
    """
 
461
 
 
462
    _matchingbzrdir = RemoteBzrDirFormat()
 
463
 
 
464
    def __init__(self):
 
465
        repository.RepositoryFormat.__init__(self)
 
466
        self._custom_format = None
 
467
        self._network_name = None
 
468
        self._creating_bzrdir = None
 
469
        self._supports_chks = None
 
470
        self._supports_external_lookups = None
 
471
        self._supports_tree_reference = None
 
472
        self._rich_root_data = None
 
473
 
 
474
    def __repr__(self):
 
475
        return "%s(_network_name=%r)" % (self.__class__.__name__,
 
476
            self._network_name)
 
477
 
 
478
    @property
 
479
    def fast_deltas(self):
 
480
        self._ensure_real()
 
481
        return self._custom_format.fast_deltas
 
482
 
 
483
    @property
 
484
    def rich_root_data(self):
 
485
        if self._rich_root_data is None:
 
486
            self._ensure_real()
 
487
            self._rich_root_data = self._custom_format.rich_root_data
 
488
        return self._rich_root_data
 
489
 
 
490
    @property
 
491
    def supports_chks(self):
 
492
        if self._supports_chks is None:
 
493
            self._ensure_real()
 
494
            self._supports_chks = self._custom_format.supports_chks
 
495
        return self._supports_chks
 
496
 
 
497
    @property
 
498
    def supports_external_lookups(self):
 
499
        if self._supports_external_lookups is None:
 
500
            self._ensure_real()
 
501
            self._supports_external_lookups = \
 
502
                self._custom_format.supports_external_lookups
 
503
        return self._supports_external_lookups
 
504
 
 
505
    @property
 
506
    def supports_tree_reference(self):
 
507
        if self._supports_tree_reference is None:
 
508
            self._ensure_real()
 
509
            self._supports_tree_reference = \
 
510
                self._custom_format.supports_tree_reference
 
511
        return self._supports_tree_reference
 
512
 
 
513
    def _vfs_initialize(self, a_bzrdir, shared):
 
514
        """Helper for common code in initialize."""
 
515
        if self._custom_format:
 
516
            # Custom format requested
 
517
            result = self._custom_format.initialize(a_bzrdir, shared=shared)
 
518
        elif self._creating_bzrdir is not None:
 
519
            # Use the format that the repository we were created to back
 
520
            # has.
 
521
            prior_repo = self._creating_bzrdir.open_repository()
 
522
            prior_repo._ensure_real()
 
523
            result = prior_repo._real_repository._format.initialize(
 
524
                a_bzrdir, shared=shared)
 
525
        else:
 
526
            # assume that a_bzr is a RemoteBzrDir but the smart server didn't
 
527
            # support remote initialization.
 
528
            # We delegate to a real object at this point (as RemoteBzrDir
 
529
            # delegate to the repository format which would lead to infinite
 
530
            # recursion if we just called a_bzrdir.create_repository.
 
531
            a_bzrdir._ensure_real()
 
532
            result = a_bzrdir._real_bzrdir.create_repository(shared=shared)
 
533
        if not isinstance(result, RemoteRepository):
 
534
            return self.open(a_bzrdir)
 
535
        else:
 
536
            return result
 
537
 
 
538
    def initialize(self, a_bzrdir, shared=False):
 
539
        # Being asked to create on a non RemoteBzrDir:
 
540
        if not isinstance(a_bzrdir, RemoteBzrDir):
 
541
            return self._vfs_initialize(a_bzrdir, shared)
 
542
        medium = a_bzrdir._client._medium
 
543
        if medium._is_remote_before((1, 13)):
 
544
            return self._vfs_initialize(a_bzrdir, shared)
 
545
        # Creating on a remote bzr dir.
 
546
        # 1) get the network name to use.
 
547
        if self._custom_format:
 
548
            network_name = self._custom_format.network_name()
 
549
        elif self._network_name:
 
550
            network_name = self._network_name
 
551
        else:
 
552
            # Select the current bzrlib default and ask for that.
 
553
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
554
            reference_format = reference_bzrdir_format.repository_format
 
555
            network_name = reference_format.network_name()
 
556
        # 2) try direct creation via RPC
 
557
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
 
558
        verb = 'BzrDir.create_repository'
 
559
        if shared:
 
560
            shared_str = 'True'
 
561
        else:
 
562
            shared_str = 'False'
 
563
        try:
 
564
            response = a_bzrdir._call(verb, path, network_name, shared_str)
 
565
        except errors.UnknownSmartMethod:
 
566
            # Fallback - use vfs methods
 
567
            medium._remember_remote_is_before((1, 13))
 
568
            return self._vfs_initialize(a_bzrdir, shared)
 
569
        else:
 
570
            # Turn the response into a RemoteRepository object.
 
571
            format = response_tuple_to_repo_format(response[1:])
 
572
            # Used to support creating a real format instance when needed.
 
573
            format._creating_bzrdir = a_bzrdir
 
574
            remote_repo = RemoteRepository(a_bzrdir, format)
 
575
            format._creating_repo = remote_repo
 
576
            return remote_repo
 
577
 
 
578
    def open(self, a_bzrdir):
 
579
        if not isinstance(a_bzrdir, RemoteBzrDir):
 
580
            raise AssertionError('%r is not a RemoteBzrDir' % (a_bzrdir,))
 
581
        return a_bzrdir.open_repository()
 
582
 
 
583
    def _ensure_real(self):
 
584
        if self._custom_format is None:
 
585
            self._custom_format = repository.network_format_registry.get(
 
586
                self._network_name)
 
587
 
 
588
    @property
 
589
    def _fetch_order(self):
 
590
        self._ensure_real()
 
591
        return self._custom_format._fetch_order
 
592
 
 
593
    @property
 
594
    def _fetch_uses_deltas(self):
 
595
        self._ensure_real()
 
596
        return self._custom_format._fetch_uses_deltas
 
597
 
 
598
    @property
 
599
    def _fetch_reconcile(self):
 
600
        self._ensure_real()
 
601
        return self._custom_format._fetch_reconcile
 
602
 
 
603
    def get_format_description(self):
 
604
        return 'bzr remote repository'
 
605
 
 
606
    def __eq__(self, other):
 
607
        return self.__class__ is other.__class__
 
608
 
 
609
    def network_name(self):
 
610
        if self._network_name:
 
611
            return self._network_name
 
612
        self._creating_repo._ensure_real()
 
613
        return self._creating_repo._real_repository._format.network_name()
 
614
 
 
615
    @property
 
616
    def pack_compresses(self):
 
617
        self._ensure_real()
 
618
        return self._custom_format.pack_compresses
 
619
 
 
620
    @property
 
621
    def _serializer(self):
 
622
        self._ensure_real()
 
623
        return self._custom_format._serializer
 
624
 
 
625
 
 
626
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin):
 
627
    """Repository accessed over rpc.
 
628
 
 
629
    For the moment most operations are performed using local transport-backed
 
630
    Repository objects.
 
631
    """
 
632
 
 
633
    def __init__(self, remote_bzrdir, format, real_repository=None, _client=None):
 
634
        """Create a RemoteRepository instance.
 
635
 
 
636
        :param remote_bzrdir: The bzrdir hosting this repository.
 
637
        :param format: The RemoteFormat object to use.
 
638
        :param real_repository: If not None, a local implementation of the
 
639
            repository logic for the repository, usually accessing the data
 
640
            via the VFS.
 
641
        :param _client: Private testing parameter - override the smart client
 
642
            to be used by the repository.
 
643
        """
 
644
        if real_repository:
 
645
            self._real_repository = real_repository
 
646
        else:
 
647
            self._real_repository = None
 
648
        self.bzrdir = remote_bzrdir
 
649
        if _client is None:
 
650
            self._client = remote_bzrdir._client
 
651
        else:
 
652
            self._client = _client
 
653
        self._format = format
 
654
        self._lock_mode = None
 
655
        self._lock_token = None
 
656
        self._lock_count = 0
 
657
        self._leave_lock = False
 
658
        # Cache of revision parents; misses are cached during read locks, and
 
659
        # write locks when no _real_repository has been set.
 
660
        self._unstacked_provider = graph.CachingParentsProvider(
 
661
            get_parent_map=self._get_parent_map_rpc)
 
662
        self._unstacked_provider.disable_cache()
 
663
        # For tests:
 
664
        # These depend on the actual remote format, so force them off for
 
665
        # maximum compatibility. XXX: In future these should depend on the
 
666
        # remote repository instance, but this is irrelevant until we perform
 
667
        # reconcile via an RPC call.
 
668
        self._reconcile_does_inventory_gc = False
 
669
        self._reconcile_fixes_text_parents = False
 
670
        self._reconcile_backsup_inventory = False
 
671
        self.base = self.bzrdir.transport.base
 
672
        # Additional places to query for data.
 
673
        self._fallback_repositories = []
 
674
 
 
675
    def __str__(self):
 
676
        return "%s(%s)" % (self.__class__.__name__, self.base)
 
677
 
 
678
    __repr__ = __str__
 
679
 
 
680
    def abort_write_group(self, suppress_errors=False):
 
681
        """Complete a write group on the decorated repository.
 
682
 
 
683
        Smart methods perform operations in a single step so this API
 
684
        is not really applicable except as a compatibility thunk
 
685
        for older plugins that don't use e.g. the CommitBuilder
 
686
        facility.
 
687
 
 
688
        :param suppress_errors: see Repository.abort_write_group.
 
689
        """
 
690
        self._ensure_real()
 
691
        return self._real_repository.abort_write_group(
 
692
            suppress_errors=suppress_errors)
 
693
 
 
694
    @property
 
695
    def chk_bytes(self):
 
696
        """Decorate the real repository for now.
 
697
 
 
698
        In the long term a full blown network facility is needed to avoid
 
699
        creating a real repository object locally.
 
700
        """
 
701
        self._ensure_real()
 
702
        return self._real_repository.chk_bytes
 
703
 
 
704
    def commit_write_group(self):
 
705
        """Complete a write group on the decorated repository.
 
706
 
 
707
        Smart methods perform operations in a single step so this API
 
708
        is not really applicable except as a compatibility thunk
 
709
        for older plugins that don't use e.g. the CommitBuilder
 
710
        facility.
 
711
        """
 
712
        self._ensure_real()
 
713
        return self._real_repository.commit_write_group()
 
714
 
 
715
    def resume_write_group(self, tokens):
 
716
        self._ensure_real()
 
717
        return self._real_repository.resume_write_group(tokens)
 
718
 
 
719
    def suspend_write_group(self):
 
720
        self._ensure_real()
 
721
        return self._real_repository.suspend_write_group()
 
722
 
 
723
    def get_missing_parent_inventories(self, check_for_missing_texts=True):
 
724
        self._ensure_real()
 
725
        return self._real_repository.get_missing_parent_inventories(
 
726
            check_for_missing_texts=check_for_missing_texts)
 
727
 
 
728
    def _get_rev_id_for_revno_vfs(self, revno, known_pair):
 
729
        self._ensure_real()
 
730
        return self._real_repository.get_rev_id_for_revno(
 
731
            revno, known_pair)
 
732
 
 
733
    def get_rev_id_for_revno(self, revno, known_pair):
 
734
        """See Repository.get_rev_id_for_revno."""
 
735
        path = self.bzrdir._path_for_remote_call(self._client)
 
736
        try:
 
737
            if self._client._medium._is_remote_before((1, 17)):
 
738
                return self._get_rev_id_for_revno_vfs(revno, known_pair)
 
739
            response = self._call(
 
740
                'Repository.get_rev_id_for_revno', path, revno, known_pair)
 
741
        except errors.UnknownSmartMethod:
 
742
            self._client._medium._remember_remote_is_before((1, 17))
 
743
            return self._get_rev_id_for_revno_vfs(revno, known_pair)
 
744
        if response[0] == 'ok':
 
745
            return True, response[1]
 
746
        elif response[0] == 'history-incomplete':
 
747
            known_pair = response[1:3]
 
748
            for fallback in self._fallback_repositories:
 
749
                found, result = fallback.get_rev_id_for_revno(revno, known_pair)
 
750
                if found:
 
751
                    return True, result
 
752
                else:
 
753
                    known_pair = result
 
754
            # Not found in any fallbacks
 
755
            return False, known_pair
 
756
        else:
 
757
            raise errors.UnexpectedSmartServerResponse(response)
 
758
 
 
759
    def _ensure_real(self):
 
760
        """Ensure that there is a _real_repository set.
 
761
 
 
762
        Used before calls to self._real_repository.
 
763
 
 
764
        Note that _ensure_real causes many roundtrips to the server which are
 
765
        not desirable, and prevents the use of smart one-roundtrip RPC's to
 
766
        perform complex operations (such as accessing parent data, streaming
 
767
        revisions etc). Adding calls to _ensure_real should only be done when
 
768
        bringing up new functionality, adding fallbacks for smart methods that
 
769
        require a fallback path, and never to replace an existing smart method
 
770
        invocation. If in doubt chat to the bzr network team.
 
771
        """
 
772
        if self._real_repository is None:
 
773
            if 'hpssvfs' in debug.debug_flags:
 
774
                import traceback
 
775
                warning('VFS Repository access triggered\n%s',
 
776
                    ''.join(traceback.format_stack()))
 
777
            self._unstacked_provider.missing_keys.clear()
 
778
            self.bzrdir._ensure_real()
 
779
            self._set_real_repository(
 
780
                self.bzrdir._real_bzrdir.open_repository())
 
781
 
 
782
    def _translate_error(self, err, **context):
 
783
        self.bzrdir._translate_error(err, repository=self, **context)
 
784
 
 
785
    def find_text_key_references(self):
 
786
        """Find the text key references within the repository.
 
787
 
 
788
        :return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
 
789
        revision_ids. Each altered file-ids has the exact revision_ids that
 
790
        altered it listed explicitly.
 
791
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
 
792
            to whether they were referred to by the inventory of the
 
793
            revision_id that they contain. The inventory texts from all present
 
794
            revision ids are assessed to generate this report.
 
795
        """
 
796
        self._ensure_real()
 
797
        return self._real_repository.find_text_key_references()
 
798
 
 
799
    def _generate_text_key_index(self):
 
800
        """Generate a new text key index for the repository.
 
801
 
 
802
        This is an expensive function that will take considerable time to run.
 
803
 
 
804
        :return: A dict mapping (file_id, revision_id) tuples to a list of
 
805
            parents, also (file_id, revision_id) tuples.
 
806
        """
 
807
        self._ensure_real()
 
808
        return self._real_repository._generate_text_key_index()
 
809
 
 
810
    def _get_revision_graph(self, revision_id):
 
811
        """Private method for using with old (< 1.2) servers to fallback."""
 
812
        if revision_id is None:
 
813
            revision_id = ''
 
814
        elif revision.is_null(revision_id):
 
815
            return {}
 
816
 
 
817
        path = self.bzrdir._path_for_remote_call(self._client)
 
818
        response = self._call_expecting_body(
 
819
            'Repository.get_revision_graph', path, revision_id)
 
820
        response_tuple, response_handler = response
 
821
        if response_tuple[0] != 'ok':
 
822
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
823
        coded = response_handler.read_body_bytes()
 
824
        if coded == '':
 
825
            # no revisions in this repository!
 
826
            return {}
 
827
        lines = coded.split('\n')
 
828
        revision_graph = {}
 
829
        for line in lines:
 
830
            d = tuple(line.split())
 
831
            revision_graph[d[0]] = d[1:]
 
832
 
 
833
        return revision_graph
 
834
 
 
835
    def _get_sink(self):
 
836
        """See Repository._get_sink()."""
 
837
        return RemoteStreamSink(self)
 
838
 
 
839
    def _get_source(self, to_format):
 
840
        """Return a source for streaming from this repository."""
 
841
        return RemoteStreamSource(self, to_format)
 
842
 
 
843
    @needs_read_lock
 
844
    def has_revision(self, revision_id):
 
845
        """True if this repository has a copy of the revision."""
 
846
        # Copy of bzrlib.repository.Repository.has_revision
 
847
        return revision_id in self.has_revisions((revision_id,))
 
848
 
 
849
    @needs_read_lock
 
850
    def has_revisions(self, revision_ids):
 
851
        """Probe to find out the presence of multiple revisions.
 
852
 
 
853
        :param revision_ids: An iterable of revision_ids.
 
854
        :return: A set of the revision_ids that were present.
 
855
        """
 
856
        # Copy of bzrlib.repository.Repository.has_revisions
 
857
        parent_map = self.get_parent_map(revision_ids)
 
858
        result = set(parent_map)
 
859
        if _mod_revision.NULL_REVISION in revision_ids:
 
860
            result.add(_mod_revision.NULL_REVISION)
 
861
        return result
 
862
 
 
863
    def _has_same_fallbacks(self, other_repo):
 
864
        """Returns true if the repositories have the same fallbacks."""
 
865
        # XXX: copied from Repository; it should be unified into a base class
 
866
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
 
867
        my_fb = self._fallback_repositories
 
868
        other_fb = other_repo._fallback_repositories
 
869
        if len(my_fb) != len(other_fb):
 
870
            return False
 
871
        for f, g in zip(my_fb, other_fb):
 
872
            if not f.has_same_location(g):
 
873
                return False
 
874
        return True
 
875
 
 
876
    def has_same_location(self, other):
 
877
        # TODO: Move to RepositoryBase and unify with the regular Repository
 
878
        # one; unfortunately the tests rely on slightly different behaviour at
 
879
        # present -- mbp 20090710
 
880
        return (self.__class__ is other.__class__ and
 
881
                self.bzrdir.transport.base == other.bzrdir.transport.base)
 
882
 
 
883
    def get_graph(self, other_repository=None):
 
884
        """Return the graph for this repository format"""
 
885
        parents_provider = self._make_parents_provider(other_repository)
 
886
        return graph.Graph(parents_provider)
 
887
 
 
888
    def gather_stats(self, revid=None, committers=None):
 
889
        """See Repository.gather_stats()."""
 
890
        path = self.bzrdir._path_for_remote_call(self._client)
 
891
        # revid can be None to indicate no revisions, not just NULL_REVISION
 
892
        if revid is None or revision.is_null(revid):
 
893
            fmt_revid = ''
 
894
        else:
 
895
            fmt_revid = revid
 
896
        if committers is None or not committers:
 
897
            fmt_committers = 'no'
 
898
        else:
 
899
            fmt_committers = 'yes'
 
900
        response_tuple, response_handler = self._call_expecting_body(
 
901
            'Repository.gather_stats', path, fmt_revid, fmt_committers)
 
902
        if response_tuple[0] != 'ok':
 
903
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
904
 
 
905
        body = response_handler.read_body_bytes()
 
906
        result = {}
 
907
        for line in body.split('\n'):
 
908
            if not line:
 
909
                continue
 
910
            key, val_text = line.split(':')
 
911
            if key in ('revisions', 'size', 'committers'):
 
912
                result[key] = int(val_text)
 
913
            elif key in ('firstrev', 'latestrev'):
 
914
                values = val_text.split(' ')[1:]
 
915
                result[key] = (float(values[0]), long(values[1]))
 
916
 
 
917
        return result
 
918
 
 
919
    def find_branches(self, using=False):
 
920
        """See Repository.find_branches()."""
 
921
        # should be an API call to the server.
 
922
        self._ensure_real()
 
923
        return self._real_repository.find_branches(using=using)
 
924
 
 
925
    def get_physical_lock_status(self):
 
926
        """See Repository.get_physical_lock_status()."""
 
927
        # should be an API call to the server.
 
928
        self._ensure_real()
 
929
        return self._real_repository.get_physical_lock_status()
 
930
 
 
931
    def is_in_write_group(self):
 
932
        """Return True if there is an open write group.
 
933
 
 
934
        write groups are only applicable locally for the smart server..
 
935
        """
 
936
        if self._real_repository:
 
937
            return self._real_repository.is_in_write_group()
 
938
 
 
939
    def is_locked(self):
 
940
        return self._lock_count >= 1
 
941
 
 
942
    def is_shared(self):
 
943
        """See Repository.is_shared()."""
 
944
        path = self.bzrdir._path_for_remote_call(self._client)
 
945
        response = self._call('Repository.is_shared', path)
 
946
        if response[0] not in ('yes', 'no'):
 
947
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
948
        return response[0] == 'yes'
 
949
 
 
950
    def is_write_locked(self):
 
951
        return self._lock_mode == 'w'
 
952
 
 
953
    def lock_read(self):
 
954
        # wrong eventually - want a local lock cache context
 
955
        if not self._lock_mode:
 
956
            self._note_lock('r')
 
957
            self._lock_mode = 'r'
 
958
            self._lock_count = 1
 
959
            self._unstacked_provider.enable_cache(cache_misses=True)
 
960
            if self._real_repository is not None:
 
961
                self._real_repository.lock_read()
 
962
            for repo in self._fallback_repositories:
 
963
                repo.lock_read()
 
964
        else:
 
965
            self._lock_count += 1
 
966
 
 
967
    def _remote_lock_write(self, token):
 
968
        path = self.bzrdir._path_for_remote_call(self._client)
 
969
        if token is None:
 
970
            token = ''
 
971
        err_context = {'token': token}
 
972
        response = self._call('Repository.lock_write', path, token,
 
973
                              **err_context)
 
974
        if response[0] == 'ok':
 
975
            ok, token = response
 
976
            return token
 
977
        else:
 
978
            raise errors.UnexpectedSmartServerResponse(response)
 
979
 
 
980
    def lock_write(self, token=None, _skip_rpc=False):
 
981
        if not self._lock_mode:
 
982
            self._note_lock('w')
 
983
            if _skip_rpc:
 
984
                if self._lock_token is not None:
 
985
                    if token != self._lock_token:
 
986
                        raise errors.TokenMismatch(token, self._lock_token)
 
987
                self._lock_token = token
 
988
            else:
 
989
                self._lock_token = self._remote_lock_write(token)
 
990
            # if self._lock_token is None, then this is something like packs or
 
991
            # svn where we don't get to lock the repo, or a weave style repository
 
992
            # where we cannot lock it over the wire and attempts to do so will
 
993
            # fail.
 
994
            if self._real_repository is not None:
 
995
                self._real_repository.lock_write(token=self._lock_token)
 
996
            if token is not None:
 
997
                self._leave_lock = True
 
998
            else:
 
999
                self._leave_lock = False
 
1000
            self._lock_mode = 'w'
 
1001
            self._lock_count = 1
 
1002
            cache_misses = self._real_repository is None
 
1003
            self._unstacked_provider.enable_cache(cache_misses=cache_misses)
 
1004
            for repo in self._fallback_repositories:
 
1005
                # Writes don't affect fallback repos
 
1006
                repo.lock_read()
 
1007
        elif self._lock_mode == 'r':
 
1008
            raise errors.ReadOnlyError(self)
 
1009
        else:
 
1010
            self._lock_count += 1
 
1011
        return self._lock_token or None
 
1012
 
 
1013
    def leave_lock_in_place(self):
 
1014
        if not self._lock_token:
 
1015
            raise NotImplementedError(self.leave_lock_in_place)
 
1016
        self._leave_lock = True
 
1017
 
 
1018
    def dont_leave_lock_in_place(self):
 
1019
        if not self._lock_token:
 
1020
            raise NotImplementedError(self.dont_leave_lock_in_place)
 
1021
        self._leave_lock = False
 
1022
 
 
1023
    def _set_real_repository(self, repository):
 
1024
        """Set the _real_repository for this repository.
 
1025
 
 
1026
        :param repository: The repository to fallback to for non-hpss
 
1027
            implemented operations.
 
1028
        """
 
1029
        if self._real_repository is not None:
 
1030
            # Replacing an already set real repository.
 
1031
            # We cannot do this [currently] if the repository is locked -
 
1032
            # synchronised state might be lost.
 
1033
            if self.is_locked():
 
1034
                raise AssertionError('_real_repository is already set')
 
1035
        if isinstance(repository, RemoteRepository):
 
1036
            raise AssertionError()
 
1037
        self._real_repository = repository
 
1038
        # three code paths happen here:
 
1039
        # 1) old servers, RemoteBranch.open() calls _ensure_real before setting
 
1040
        # up stacking. In this case self._fallback_repositories is [], and the
 
1041
        # real repo is already setup. Preserve the real repo and
 
1042
        # RemoteRepository.add_fallback_repository will avoid adding
 
1043
        # duplicates.
 
1044
        # 2) new servers, RemoteBranch.open() sets up stacking, and when
 
1045
        # ensure_real is triggered from a branch, the real repository to
 
1046
        # set already has a matching list with separate instances, but
 
1047
        # as they are also RemoteRepositories we don't worry about making the
 
1048
        # lists be identical.
 
1049
        # 3) new servers, RemoteRepository.ensure_real is triggered before
 
1050
        # RemoteBranch.ensure real, in this case we get a repo with no fallbacks
 
1051
        # and need to populate it.
 
1052
        if (self._fallback_repositories and
 
1053
            len(self._real_repository._fallback_repositories) !=
 
1054
            len(self._fallback_repositories)):
 
1055
            if len(self._real_repository._fallback_repositories):
 
1056
                raise AssertionError(
 
1057
                    "cannot cleanly remove existing _fallback_repositories")
 
1058
        for fb in self._fallback_repositories:
 
1059
            self._real_repository.add_fallback_repository(fb)
 
1060
        if self._lock_mode == 'w':
 
1061
            # if we are already locked, the real repository must be able to
 
1062
            # acquire the lock with our token.
 
1063
            self._real_repository.lock_write(self._lock_token)
 
1064
        elif self._lock_mode == 'r':
 
1065
            self._real_repository.lock_read()
 
1066
 
 
1067
    def start_write_group(self):
 
1068
        """Start a write group on the decorated repository.
 
1069
 
 
1070
        Smart methods perform operations in a single step so this API
 
1071
        is not really applicable except as a compatibility thunk
 
1072
        for older plugins that don't use e.g. the CommitBuilder
 
1073
        facility.
 
1074
        """
 
1075
        self._ensure_real()
 
1076
        return self._real_repository.start_write_group()
 
1077
 
 
1078
    def _unlock(self, token):
 
1079
        path = self.bzrdir._path_for_remote_call(self._client)
 
1080
        if not token:
 
1081
            # with no token the remote repository is not persistently locked.
 
1082
            return
 
1083
        err_context = {'token': token}
 
1084
        response = self._call('Repository.unlock', path, token,
 
1085
                              **err_context)
 
1086
        if response == ('ok',):
 
1087
            return
 
1088
        else:
 
1089
            raise errors.UnexpectedSmartServerResponse(response)
 
1090
 
 
1091
    @only_raises(errors.LockNotHeld, errors.LockBroken)
 
1092
    def unlock(self):
 
1093
        if not self._lock_count:
 
1094
            return lock.cant_unlock_not_held(self)
 
1095
        self._lock_count -= 1
 
1096
        if self._lock_count > 0:
 
1097
            return
 
1098
        self._unstacked_provider.disable_cache()
 
1099
        old_mode = self._lock_mode
 
1100
        self._lock_mode = None
 
1101
        try:
 
1102
            # The real repository is responsible at present for raising an
 
1103
            # exception if it's in an unfinished write group.  However, it
 
1104
            # normally will *not* actually remove the lock from disk - that's
 
1105
            # done by the server on receiving the Repository.unlock call.
 
1106
            # This is just to let the _real_repository stay up to date.
 
1107
            if self._real_repository is not None:
 
1108
                self._real_repository.unlock()
 
1109
        finally:
 
1110
            # The rpc-level lock should be released even if there was a
 
1111
            # problem releasing the vfs-based lock.
 
1112
            if old_mode == 'w':
 
1113
                # Only write-locked repositories need to make a remote method
 
1114
                # call to perform the unlock.
 
1115
                old_token = self._lock_token
 
1116
                self._lock_token = None
 
1117
                if not self._leave_lock:
 
1118
                    self._unlock(old_token)
 
1119
        # Fallbacks are always 'lock_read()' so we don't pay attention to
 
1120
        # self._leave_lock
 
1121
        for repo in self._fallback_repositories:
 
1122
            repo.unlock()
 
1123
 
 
1124
    def break_lock(self):
 
1125
        # should hand off to the network
 
1126
        self._ensure_real()
 
1127
        return self._real_repository.break_lock()
 
1128
 
 
1129
    def _get_tarball(self, compression):
 
1130
        """Return a TemporaryFile containing a repository tarball.
 
1131
 
 
1132
        Returns None if the server does not support sending tarballs.
 
1133
        """
 
1134
        import tempfile
 
1135
        path = self.bzrdir._path_for_remote_call(self._client)
 
1136
        try:
 
1137
            response, protocol = self._call_expecting_body(
 
1138
                'Repository.tarball', path, compression)
 
1139
        except errors.UnknownSmartMethod:
 
1140
            protocol.cancel_read_body()
 
1141
            return None
 
1142
        if response[0] == 'ok':
 
1143
            # Extract the tarball and return it
 
1144
            t = tempfile.NamedTemporaryFile()
 
1145
            # TODO: rpc layer should read directly into it...
 
1146
            t.write(protocol.read_body_bytes())
 
1147
            t.seek(0)
 
1148
            return t
 
1149
        raise errors.UnexpectedSmartServerResponse(response)
 
1150
 
 
1151
    def sprout(self, to_bzrdir, revision_id=None):
 
1152
        # TODO: Option to control what format is created?
 
1153
        self._ensure_real()
 
1154
        dest_repo = self._real_repository._format.initialize(to_bzrdir,
 
1155
                                                             shared=False)
 
1156
        dest_repo.fetch(self, revision_id=revision_id)
 
1157
        return dest_repo
 
1158
 
 
1159
    ### These methods are just thin shims to the VFS object for now.
 
1160
 
 
1161
    def revision_tree(self, revision_id):
 
1162
        self._ensure_real()
 
1163
        return self._real_repository.revision_tree(revision_id)
 
1164
 
 
1165
    def get_serializer_format(self):
 
1166
        self._ensure_real()
 
1167
        return self._real_repository.get_serializer_format()
 
1168
 
 
1169
    def get_commit_builder(self, branch, parents, config, timestamp=None,
 
1170
                           timezone=None, committer=None, revprops=None,
 
1171
                           revision_id=None):
 
1172
        # FIXME: It ought to be possible to call this without immediately
 
1173
        # triggering _ensure_real.  For now it's the easiest thing to do.
 
1174
        self._ensure_real()
 
1175
        real_repo = self._real_repository
 
1176
        builder = real_repo.get_commit_builder(branch, parents,
 
1177
                config, timestamp=timestamp, timezone=timezone,
 
1178
                committer=committer, revprops=revprops, revision_id=revision_id)
 
1179
        return builder
 
1180
 
 
1181
    def add_fallback_repository(self, repository):
 
1182
        """Add a repository to use for looking up data not held locally.
 
1183
 
 
1184
        :param repository: A repository.
 
1185
        """
 
1186
        if not self._format.supports_external_lookups:
 
1187
            raise errors.UnstackableRepositoryFormat(
 
1188
                self._format.network_name(), self.base)
 
1189
        # We need to accumulate additional repositories here, to pass them in
 
1190
        # on various RPC's.
 
1191
        #
 
1192
        if self.is_locked():
 
1193
            # We will call fallback.unlock() when we transition to the unlocked
 
1194
            # state, so always add a lock here. If a caller passes us a locked
 
1195
            # repository, they are responsible for unlocking it later.
 
1196
            repository.lock_read()
 
1197
        self._fallback_repositories.append(repository)
 
1198
        # If self._real_repository was parameterised already (e.g. because a
 
1199
        # _real_branch had its get_stacked_on_url method called), then the
 
1200
        # repository to be added may already be in the _real_repositories list.
 
1201
        if self._real_repository is not None:
 
1202
            fallback_locations = [repo.bzrdir.root_transport.base for repo in
 
1203
                self._real_repository._fallback_repositories]
 
1204
            if repository.bzrdir.root_transport.base not in fallback_locations:
 
1205
                self._real_repository.add_fallback_repository(repository)
 
1206
 
 
1207
    def add_inventory(self, revid, inv, parents):
 
1208
        self._ensure_real()
 
1209
        return self._real_repository.add_inventory(revid, inv, parents)
 
1210
 
 
1211
    def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
 
1212
                               parents):
 
1213
        self._ensure_real()
 
1214
        return self._real_repository.add_inventory_by_delta(basis_revision_id,
 
1215
            delta, new_revision_id, parents)
 
1216
 
 
1217
    def add_revision(self, rev_id, rev, inv=None, config=None):
 
1218
        self._ensure_real()
 
1219
        return self._real_repository.add_revision(
 
1220
            rev_id, rev, inv=inv, config=config)
 
1221
 
 
1222
    @needs_read_lock
 
1223
    def get_inventory(self, revision_id):
 
1224
        self._ensure_real()
 
1225
        return self._real_repository.get_inventory(revision_id)
 
1226
 
 
1227
    def iter_inventories(self, revision_ids, ordering=None):
 
1228
        self._ensure_real()
 
1229
        return self._real_repository.iter_inventories(revision_ids, ordering)
 
1230
 
 
1231
    @needs_read_lock
 
1232
    def get_revision(self, revision_id):
 
1233
        self._ensure_real()
 
1234
        return self._real_repository.get_revision(revision_id)
 
1235
 
 
1236
    def get_transaction(self):
 
1237
        self._ensure_real()
 
1238
        return self._real_repository.get_transaction()
 
1239
 
 
1240
    @needs_read_lock
 
1241
    def clone(self, a_bzrdir, revision_id=None):
 
1242
        self._ensure_real()
 
1243
        return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
 
1244
 
 
1245
    def make_working_trees(self):
 
1246
        """See Repository.make_working_trees"""
 
1247
        self._ensure_real()
 
1248
        return self._real_repository.make_working_trees()
 
1249
 
 
1250
    def refresh_data(self):
 
1251
        """Re-read any data needed to to synchronise with disk.
 
1252
 
 
1253
        This method is intended to be called after another repository instance
 
1254
        (such as one used by a smart server) has inserted data into the
 
1255
        repository. It may not be called during a write group, but may be
 
1256
        called at any other time.
 
1257
        """
 
1258
        if self.is_in_write_group():
 
1259
            raise errors.InternalBzrError(
 
1260
                "May not refresh_data while in a write group.")
 
1261
        if self._real_repository is not None:
 
1262
            self._real_repository.refresh_data()
 
1263
 
 
1264
    def revision_ids_to_search_result(self, result_set):
 
1265
        """Convert a set of revision ids to a graph SearchResult."""
 
1266
        result_parents = set()
 
1267
        for parents in self.get_graph().get_parent_map(
 
1268
            result_set).itervalues():
 
1269
            result_parents.update(parents)
 
1270
        included_keys = result_set.intersection(result_parents)
 
1271
        start_keys = result_set.difference(included_keys)
 
1272
        exclude_keys = result_parents.difference(result_set)
 
1273
        result = graph.SearchResult(start_keys, exclude_keys,
 
1274
            len(result_set), result_set)
 
1275
        return result
 
1276
 
 
1277
    @needs_read_lock
 
1278
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
 
1279
        """Return the revision ids that other has that this does not.
 
1280
 
 
1281
        These are returned in topological order.
 
1282
 
 
1283
        revision_id: only return revision ids included by revision_id.
 
1284
        """
 
1285
        return repository.InterRepository.get(
 
1286
            other, self).search_missing_revision_ids(revision_id, find_ghosts)
 
1287
 
 
1288
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
 
1289
            fetch_spec=None):
 
1290
        # No base implementation to use as RemoteRepository is not a subclass
 
1291
        # of Repository; so this is a copy of Repository.fetch().
 
1292
        if fetch_spec is not None and revision_id is not None:
 
1293
            raise AssertionError(
 
1294
                "fetch_spec and revision_id are mutually exclusive.")
 
1295
        if self.is_in_write_group():
 
1296
            raise errors.InternalBzrError(
 
1297
                "May not fetch while in a write group.")
 
1298
        # fast path same-url fetch operations
 
1299
        if (self.has_same_location(source)
 
1300
            and fetch_spec is None
 
1301
            and self._has_same_fallbacks(source)):
 
1302
            # check that last_revision is in 'from' and then return a
 
1303
            # no-operation.
 
1304
            if (revision_id is not None and
 
1305
                not revision.is_null(revision_id)):
 
1306
                self.get_revision(revision_id)
 
1307
            return 0, []
 
1308
        # if there is no specific appropriate InterRepository, this will get
 
1309
        # the InterRepository base class, which raises an
 
1310
        # IncompatibleRepositories when asked to fetch.
 
1311
        inter = repository.InterRepository.get(source, self)
 
1312
        return inter.fetch(revision_id=revision_id, pb=pb,
 
1313
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
 
1314
 
 
1315
    def create_bundle(self, target, base, fileobj, format=None):
 
1316
        self._ensure_real()
 
1317
        self._real_repository.create_bundle(target, base, fileobj, format)
 
1318
 
 
1319
    @needs_read_lock
 
1320
    def get_ancestry(self, revision_id, topo_sorted=True):
 
1321
        self._ensure_real()
 
1322
        return self._real_repository.get_ancestry(revision_id, topo_sorted)
 
1323
 
 
1324
    def fileids_altered_by_revision_ids(self, revision_ids):
 
1325
        self._ensure_real()
 
1326
        return self._real_repository.fileids_altered_by_revision_ids(revision_ids)
 
1327
 
 
1328
    def _get_versioned_file_checker(self, revisions, revision_versions_cache):
 
1329
        self._ensure_real()
 
1330
        return self._real_repository._get_versioned_file_checker(
 
1331
            revisions, revision_versions_cache)
 
1332
 
 
1333
    def iter_files_bytes(self, desired_files):
 
1334
        """See Repository.iter_file_bytes.
 
1335
        """
 
1336
        self._ensure_real()
 
1337
        return self._real_repository.iter_files_bytes(desired_files)
 
1338
 
 
1339
    def get_parent_map(self, revision_ids):
 
1340
        """See bzrlib.Graph.get_parent_map()."""
 
1341
        return self._make_parents_provider().get_parent_map(revision_ids)
 
1342
 
 
1343
    def _get_parent_map_rpc(self, keys):
 
1344
        """Helper for get_parent_map that performs the RPC."""
 
1345
        medium = self._client._medium
 
1346
        if medium._is_remote_before((1, 2)):
 
1347
            # We already found out that the server can't understand
 
1348
            # Repository.get_parent_map requests, so just fetch the whole
 
1349
            # graph.
 
1350
            #
 
1351
            # Note that this reads the whole graph, when only some keys are
 
1352
            # wanted.  On this old server there's no way (?) to get them all
 
1353
            # in one go, and the user probably will have seen a warning about
 
1354
            # the server being old anyhow.
 
1355
            rg = self._get_revision_graph(None)
 
1356
            # There is an API discrepancy between get_parent_map and
 
1357
            # get_revision_graph. Specifically, a "key:()" pair in
 
1358
            # get_revision_graph just means a node has no parents. For
 
1359
            # "get_parent_map" it means the node is a ghost. So fix up the
 
1360
            # graph to correct this.
 
1361
            #   https://bugs.launchpad.net/bzr/+bug/214894
 
1362
            # There is one other "bug" which is that ghosts in
 
1363
            # get_revision_graph() are not returned at all. But we won't worry
 
1364
            # about that for now.
 
1365
            for node_id, parent_ids in rg.iteritems():
 
1366
                if parent_ids == ():
 
1367
                    rg[node_id] = (NULL_REVISION,)
 
1368
            rg[NULL_REVISION] = ()
 
1369
            return rg
 
1370
 
 
1371
        keys = set(keys)
 
1372
        if None in keys:
 
1373
            raise ValueError('get_parent_map(None) is not valid')
 
1374
        if NULL_REVISION in keys:
 
1375
            keys.discard(NULL_REVISION)
 
1376
            found_parents = {NULL_REVISION:()}
 
1377
            if not keys:
 
1378
                return found_parents
 
1379
        else:
 
1380
            found_parents = {}
 
1381
        # TODO(Needs analysis): We could assume that the keys being requested
 
1382
        # from get_parent_map are in a breadth first search, so typically they
 
1383
        # will all be depth N from some common parent, and we don't have to
 
1384
        # have the server iterate from the root parent, but rather from the
 
1385
        # keys we're searching; and just tell the server the keyspace we
 
1386
        # already have; but this may be more traffic again.
 
1387
 
 
1388
        # Transform self._parents_map into a search request recipe.
 
1389
        # TODO: Manage this incrementally to avoid covering the same path
 
1390
        # repeatedly. (The server will have to on each request, but the less
 
1391
        # work done the better).
 
1392
        #
 
1393
        # Negative caching notes:
 
1394
        # new server sends missing when a request including the revid
 
1395
        # 'include-missing:' is present in the request.
 
1396
        # missing keys are serialised as missing:X, and we then call
 
1397
        # provider.note_missing(X) for-all X
 
1398
        parents_map = self._unstacked_provider.get_cached_map()
 
1399
        if parents_map is None:
 
1400
            # Repository is not locked, so there's no cache.
 
1401
            parents_map = {}
 
1402
        # start_set is all the keys in the cache
 
1403
        start_set = set(parents_map)
 
1404
        # result set is all the references to keys in the cache
 
1405
        result_parents = set()
 
1406
        for parents in parents_map.itervalues():
 
1407
            result_parents.update(parents)
 
1408
        stop_keys = result_parents.difference(start_set)
 
1409
        # We don't need to send ghosts back to the server as a position to
 
1410
        # stop either.
 
1411
        stop_keys.difference_update(self._unstacked_provider.missing_keys)
 
1412
        key_count = len(parents_map)
 
1413
        if (NULL_REVISION in result_parents
 
1414
            and NULL_REVISION in self._unstacked_provider.missing_keys):
 
1415
            # If we pruned NULL_REVISION from the stop_keys because it's also
 
1416
            # in our cache of "missing" keys we need to increment our key count
 
1417
            # by 1, because the reconsitituted SearchResult on the server will
 
1418
            # still consider NULL_REVISION to be an included key.
 
1419
            key_count += 1
 
1420
        included_keys = start_set.intersection(result_parents)
 
1421
        start_set.difference_update(included_keys)
 
1422
        recipe = ('manual', start_set, stop_keys, key_count)
 
1423
        body = self._serialise_search_recipe(recipe)
 
1424
        path = self.bzrdir._path_for_remote_call(self._client)
 
1425
        for key in keys:
 
1426
            if type(key) is not str:
 
1427
                raise ValueError(
 
1428
                    "key %r not a plain string" % (key,))
 
1429
        verb = 'Repository.get_parent_map'
 
1430
        args = (path, 'include-missing:') + tuple(keys)
 
1431
        try:
 
1432
            response = self._call_with_body_bytes_expecting_body(
 
1433
                verb, args, body)
 
1434
        except errors.UnknownSmartMethod:
 
1435
            # Server does not support this method, so get the whole graph.
 
1436
            # Worse, we have to force a disconnection, because the server now
 
1437
            # doesn't realise it has a body on the wire to consume, so the
 
1438
            # only way to recover is to abandon the connection.
 
1439
            warning(
 
1440
                'Server is too old for fast get_parent_map, reconnecting.  '
 
1441
                '(Upgrade the server to Bazaar 1.2 to avoid this)')
 
1442
            medium.disconnect()
 
1443
            # To avoid having to disconnect repeatedly, we keep track of the
 
1444
            # fact the server doesn't understand remote methods added in 1.2.
 
1445
            medium._remember_remote_is_before((1, 2))
 
1446
            # Recurse just once and we should use the fallback code.
 
1447
            return self._get_parent_map_rpc(keys)
 
1448
        response_tuple, response_handler = response
 
1449
        if response_tuple[0] not in ['ok']:
 
1450
            response_handler.cancel_read_body()
 
1451
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
1452
        if response_tuple[0] == 'ok':
 
1453
            coded = bz2.decompress(response_handler.read_body_bytes())
 
1454
            if coded == '':
 
1455
                # no revisions found
 
1456
                return {}
 
1457
            lines = coded.split('\n')
 
1458
            revision_graph = {}
 
1459
            for line in lines:
 
1460
                d = tuple(line.split())
 
1461
                if len(d) > 1:
 
1462
                    revision_graph[d[0]] = d[1:]
 
1463
                else:
 
1464
                    # No parents:
 
1465
                    if d[0].startswith('missing:'):
 
1466
                        revid = d[0][8:]
 
1467
                        self._unstacked_provider.note_missing_key(revid)
 
1468
                    else:
 
1469
                        # no parents - so give the Graph result
 
1470
                        # (NULL_REVISION,).
 
1471
                        revision_graph[d[0]] = (NULL_REVISION,)
 
1472
            return revision_graph
 
1473
 
 
1474
    @needs_read_lock
 
1475
    def get_signature_text(self, revision_id):
 
1476
        self._ensure_real()
 
1477
        return self._real_repository.get_signature_text(revision_id)
 
1478
 
 
1479
    @needs_read_lock
 
1480
    def get_inventory_xml(self, revision_id):
 
1481
        self._ensure_real()
 
1482
        return self._real_repository.get_inventory_xml(revision_id)
 
1483
 
 
1484
    def deserialise_inventory(self, revision_id, xml):
 
1485
        self._ensure_real()
 
1486
        return self._real_repository.deserialise_inventory(revision_id, xml)
 
1487
 
 
1488
    def reconcile(self, other=None, thorough=False):
 
1489
        self._ensure_real()
 
1490
        return self._real_repository.reconcile(other=other, thorough=thorough)
 
1491
 
 
1492
    def all_revision_ids(self):
 
1493
        self._ensure_real()
 
1494
        return self._real_repository.all_revision_ids()
 
1495
 
 
1496
    @needs_read_lock
 
1497
    def get_deltas_for_revisions(self, revisions, specific_fileids=None):
 
1498
        self._ensure_real()
 
1499
        return self._real_repository.get_deltas_for_revisions(revisions,
 
1500
            specific_fileids=specific_fileids)
 
1501
 
 
1502
    @needs_read_lock
 
1503
    def get_revision_delta(self, revision_id, specific_fileids=None):
 
1504
        self._ensure_real()
 
1505
        return self._real_repository.get_revision_delta(revision_id,
 
1506
            specific_fileids=specific_fileids)
 
1507
 
 
1508
    @needs_read_lock
 
1509
    def revision_trees(self, revision_ids):
 
1510
        self._ensure_real()
 
1511
        return self._real_repository.revision_trees(revision_ids)
 
1512
 
 
1513
    @needs_read_lock
 
1514
    def get_revision_reconcile(self, revision_id):
 
1515
        self._ensure_real()
 
1516
        return self._real_repository.get_revision_reconcile(revision_id)
 
1517
 
 
1518
    @needs_read_lock
 
1519
    def check(self, revision_ids=None, callback_refs=None, check_repo=True):
 
1520
        self._ensure_real()
 
1521
        return self._real_repository.check(revision_ids=revision_ids,
 
1522
            callback_refs=callback_refs, check_repo=check_repo)
 
1523
 
 
1524
    def copy_content_into(self, destination, revision_id=None):
 
1525
        self._ensure_real()
 
1526
        return self._real_repository.copy_content_into(
 
1527
            destination, revision_id=revision_id)
 
1528
 
 
1529
    def _copy_repository_tarball(self, to_bzrdir, revision_id=None):
 
1530
        # get a tarball of the remote repository, and copy from that into the
 
1531
        # destination
 
1532
        from bzrlib import osutils
 
1533
        import tarfile
 
1534
        # TODO: Maybe a progress bar while streaming the tarball?
 
1535
        note("Copying repository content as tarball...")
 
1536
        tar_file = self._get_tarball('bz2')
 
1537
        if tar_file is None:
 
1538
            return None
 
1539
        destination = to_bzrdir.create_repository()
 
1540
        try:
 
1541
            tar = tarfile.open('repository', fileobj=tar_file,
 
1542
                mode='r|bz2')
 
1543
            tmpdir = osutils.mkdtemp()
 
1544
            try:
 
1545
                _extract_tar(tar, tmpdir)
 
1546
                tmp_bzrdir = BzrDir.open(tmpdir)
 
1547
                tmp_repo = tmp_bzrdir.open_repository()
 
1548
                tmp_repo.copy_content_into(destination, revision_id)
 
1549
            finally:
 
1550
                osutils.rmtree(tmpdir)
 
1551
        finally:
 
1552
            tar_file.close()
 
1553
        return destination
 
1554
        # TODO: Suggestion from john: using external tar is much faster than
 
1555
        # python's tarfile library, but it may not work on windows.
 
1556
 
 
1557
    @property
 
1558
    def inventories(self):
 
1559
        """Decorate the real repository for now.
 
1560
 
 
1561
        In the long term a full blown network facility is needed to
 
1562
        avoid creating a real repository object locally.
 
1563
        """
 
1564
        self._ensure_real()
 
1565
        return self._real_repository.inventories
 
1566
 
 
1567
    @needs_write_lock
 
1568
    def pack(self, hint=None):
 
1569
        """Compress the data within the repository.
 
1570
 
 
1571
        This is not currently implemented within the smart server.
 
1572
        """
 
1573
        self._ensure_real()
 
1574
        return self._real_repository.pack(hint=hint)
 
1575
 
 
1576
    @property
 
1577
    def revisions(self):
 
1578
        """Decorate the real repository for now.
 
1579
 
 
1580
        In the short term this should become a real object to intercept graph
 
1581
        lookups.
 
1582
 
 
1583
        In the long term a full blown network facility is needed.
 
1584
        """
 
1585
        self._ensure_real()
 
1586
        return self._real_repository.revisions
 
1587
 
 
1588
    def set_make_working_trees(self, new_value):
 
1589
        if new_value:
 
1590
            new_value_str = "True"
 
1591
        else:
 
1592
            new_value_str = "False"
 
1593
        path = self.bzrdir._path_for_remote_call(self._client)
 
1594
        try:
 
1595
            response = self._call(
 
1596
                'Repository.set_make_working_trees', path, new_value_str)
 
1597
        except errors.UnknownSmartMethod:
 
1598
            self._ensure_real()
 
1599
            self._real_repository.set_make_working_trees(new_value)
 
1600
        else:
 
1601
            if response[0] != 'ok':
 
1602
                raise errors.UnexpectedSmartServerResponse(response)
 
1603
 
 
1604
    @property
 
1605
    def signatures(self):
 
1606
        """Decorate the real repository for now.
 
1607
 
 
1608
        In the long term a full blown network facility is needed to avoid
 
1609
        creating a real repository object locally.
 
1610
        """
 
1611
        self._ensure_real()
 
1612
        return self._real_repository.signatures
 
1613
 
 
1614
    @needs_write_lock
 
1615
    def sign_revision(self, revision_id, gpg_strategy):
 
1616
        self._ensure_real()
 
1617
        return self._real_repository.sign_revision(revision_id, gpg_strategy)
 
1618
 
 
1619
    @property
 
1620
    def texts(self):
 
1621
        """Decorate the real repository for now.
 
1622
 
 
1623
        In the long term a full blown network facility is needed to avoid
 
1624
        creating a real repository object locally.
 
1625
        """
 
1626
        self._ensure_real()
 
1627
        return self._real_repository.texts
 
1628
 
 
1629
    @needs_read_lock
 
1630
    def get_revisions(self, revision_ids):
 
1631
        self._ensure_real()
 
1632
        return self._real_repository.get_revisions(revision_ids)
 
1633
 
 
1634
    def supports_rich_root(self):
 
1635
        return self._format.rich_root_data
 
1636
 
 
1637
    def iter_reverse_revision_history(self, revision_id):
 
1638
        self._ensure_real()
 
1639
        return self._real_repository.iter_reverse_revision_history(revision_id)
 
1640
 
 
1641
    @property
 
1642
    def _serializer(self):
 
1643
        return self._format._serializer
 
1644
 
 
1645
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
 
1646
        self._ensure_real()
 
1647
        return self._real_repository.store_revision_signature(
 
1648
            gpg_strategy, plaintext, revision_id)
 
1649
 
 
1650
    def add_signature_text(self, revision_id, signature):
 
1651
        self._ensure_real()
 
1652
        return self._real_repository.add_signature_text(revision_id, signature)
 
1653
 
 
1654
    def has_signature_for_revision_id(self, revision_id):
 
1655
        self._ensure_real()
 
1656
        return self._real_repository.has_signature_for_revision_id(revision_id)
 
1657
 
 
1658
    def item_keys_introduced_by(self, revision_ids, _files_pb=None):
 
1659
        self._ensure_real()
 
1660
        return self._real_repository.item_keys_introduced_by(revision_ids,
 
1661
            _files_pb=_files_pb)
 
1662
 
 
1663
    def revision_graph_can_have_wrong_parents(self):
 
1664
        # The answer depends on the remote repo format.
 
1665
        self._ensure_real()
 
1666
        return self._real_repository.revision_graph_can_have_wrong_parents()
 
1667
 
 
1668
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
 
1669
        self._ensure_real()
 
1670
        return self._real_repository._find_inconsistent_revision_parents(
 
1671
            revisions_iterator)
 
1672
 
 
1673
    def _check_for_inconsistent_revision_parents(self):
 
1674
        self._ensure_real()
 
1675
        return self._real_repository._check_for_inconsistent_revision_parents()
 
1676
 
 
1677
    def _make_parents_provider(self, other=None):
 
1678
        providers = [self._unstacked_provider]
 
1679
        if other is not None:
 
1680
            providers.insert(0, other)
 
1681
        providers.extend(r._make_parents_provider() for r in
 
1682
                         self._fallback_repositories)
 
1683
        return graph.StackedParentsProvider(providers)
 
1684
 
 
1685
    def _serialise_search_recipe(self, recipe):
 
1686
        """Serialise a graph search recipe.
 
1687
 
 
1688
        :param recipe: A search recipe (start, stop, count).
 
1689
        :return: Serialised bytes.
 
1690
        """
 
1691
        start_keys = ' '.join(recipe[1])
 
1692
        stop_keys = ' '.join(recipe[2])
 
1693
        count = str(recipe[3])
 
1694
        return '\n'.join((start_keys, stop_keys, count))
 
1695
 
 
1696
    def _serialise_search_result(self, search_result):
 
1697
        if isinstance(search_result, graph.PendingAncestryResult):
 
1698
            parts = ['ancestry-of']
 
1699
            parts.extend(search_result.heads)
 
1700
        else:
 
1701
            recipe = search_result.get_recipe()
 
1702
            parts = [recipe[0], self._serialise_search_recipe(recipe)]
 
1703
        return '\n'.join(parts)
 
1704
 
 
1705
    def autopack(self):
 
1706
        path = self.bzrdir._path_for_remote_call(self._client)
 
1707
        try:
 
1708
            response = self._call('PackRepository.autopack', path)
 
1709
        except errors.UnknownSmartMethod:
 
1710
            self._ensure_real()
 
1711
            self._real_repository._pack_collection.autopack()
 
1712
            return
 
1713
        self.refresh_data()
 
1714
        if response[0] != 'ok':
 
1715
            raise errors.UnexpectedSmartServerResponse(response)
 
1716
 
 
1717
 
 
1718
class RemoteStreamSink(repository.StreamSink):
 
1719
 
 
1720
    def _insert_real(self, stream, src_format, resume_tokens):
 
1721
        self.target_repo._ensure_real()
 
1722
        sink = self.target_repo._real_repository._get_sink()
 
1723
        result = sink.insert_stream(stream, src_format, resume_tokens)
 
1724
        if not result:
 
1725
            self.target_repo.autopack()
 
1726
        return result
 
1727
 
 
1728
    def insert_stream(self, stream, src_format, resume_tokens):
 
1729
        target = self.target_repo
 
1730
        target._unstacked_provider.missing_keys.clear()
 
1731
        candidate_calls = [('Repository.insert_stream_1.19', (1, 19))]
 
1732
        if target._lock_token:
 
1733
            candidate_calls.append(('Repository.insert_stream_locked', (1, 14)))
 
1734
            lock_args = (target._lock_token or '',)
 
1735
        else:
 
1736
            candidate_calls.append(('Repository.insert_stream', (1, 13)))
 
1737
            lock_args = ()
 
1738
        client = target._client
 
1739
        medium = client._medium
 
1740
        path = target.bzrdir._path_for_remote_call(client)
 
1741
        # Probe for the verb to use with an empty stream before sending the
 
1742
        # real stream to it.  We do this both to avoid the risk of sending a
 
1743
        # large request that is then rejected, and because we don't want to
 
1744
        # implement a way to buffer, rewind, or restart the stream.
 
1745
        found_verb = False
 
1746
        for verb, required_version in candidate_calls:
 
1747
            if medium._is_remote_before(required_version):
 
1748
                continue
 
1749
            if resume_tokens:
 
1750
                # We've already done the probing (and set _is_remote_before) on
 
1751
                # a previous insert.
 
1752
                found_verb = True
 
1753
                break
 
1754
            byte_stream = smart_repo._stream_to_byte_stream([], src_format)
 
1755
            try:
 
1756
                response = client.call_with_body_stream(
 
1757
                    (verb, path, '') + lock_args, byte_stream)
 
1758
            except errors.UnknownSmartMethod:
 
1759
                medium._remember_remote_is_before(required_version)
 
1760
            else:
 
1761
                found_verb = True
 
1762
                break
 
1763
        if not found_verb:
 
1764
            # Have to use VFS.
 
1765
            return self._insert_real(stream, src_format, resume_tokens)
 
1766
        self._last_inv_record = None
 
1767
        self._last_substream = None
 
1768
        if required_version < (1, 19):
 
1769
            # Remote side doesn't support inventory deltas.  Wrap the stream to
 
1770
            # make sure we don't send any.  If the stream contains inventory
 
1771
            # deltas we'll interrupt the smart insert_stream request and
 
1772
            # fallback to VFS.
 
1773
            stream = self._stop_stream_if_inventory_delta(stream)
 
1774
        byte_stream = smart_repo._stream_to_byte_stream(
 
1775
            stream, src_format)
 
1776
        resume_tokens = ' '.join(resume_tokens)
 
1777
        response = client.call_with_body_stream(
 
1778
            (verb, path, resume_tokens) + lock_args, byte_stream)
 
1779
        if response[0][0] not in ('ok', 'missing-basis'):
 
1780
            raise errors.UnexpectedSmartServerResponse(response)
 
1781
        if self._last_substream is not None:
 
1782
            # The stream included an inventory-delta record, but the remote
 
1783
            # side isn't new enough to support them.  So we need to send the
 
1784
            # rest of the stream via VFS.
 
1785
            self.target_repo.refresh_data()
 
1786
            return self._resume_stream_with_vfs(response, src_format)
 
1787
        if response[0][0] == 'missing-basis':
 
1788
            tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
 
1789
            resume_tokens = tokens
 
1790
            return resume_tokens, set(missing_keys)
 
1791
        else:
 
1792
            self.target_repo.refresh_data()
 
1793
            return [], set()
 
1794
 
 
1795
    def _resume_stream_with_vfs(self, response, src_format):
 
1796
        """Resume sending a stream via VFS, first resending the record and
 
1797
        substream that couldn't be sent via an insert_stream verb.
 
1798
        """
 
1799
        if response[0][0] == 'missing-basis':
 
1800
            tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
 
1801
            # Ignore missing_keys, we haven't finished inserting yet
 
1802
        else:
 
1803
            tokens = []
 
1804
        def resume_substream():
 
1805
            # Yield the substream that was interrupted.
 
1806
            for record in self._last_substream:
 
1807
                yield record
 
1808
            self._last_substream = None
 
1809
        def resume_stream():
 
1810
            # Finish sending the interrupted substream
 
1811
            yield ('inventory-deltas', resume_substream())
 
1812
            # Then simply continue sending the rest of the stream.
 
1813
            for substream_kind, substream in self._last_stream:
 
1814
                yield substream_kind, substream
 
1815
        return self._insert_real(resume_stream(), src_format, tokens)
 
1816
 
 
1817
    def _stop_stream_if_inventory_delta(self, stream):
 
1818
        """Normally this just lets the original stream pass-through unchanged.
 
1819
 
 
1820
        However if any 'inventory-deltas' substream occurs it will stop
 
1821
        streaming, and store the interrupted substream and stream in
 
1822
        self._last_substream and self._last_stream so that the stream can be
 
1823
        resumed by _resume_stream_with_vfs.
 
1824
        """
 
1825
                    
 
1826
        stream_iter = iter(stream)
 
1827
        for substream_kind, substream in stream_iter:
 
1828
            if substream_kind == 'inventory-deltas':
 
1829
                self._last_substream = substream
 
1830
                self._last_stream = stream_iter
 
1831
                return
 
1832
            else:
 
1833
                yield substream_kind, substream
 
1834
            
 
1835
 
 
1836
class RemoteStreamSource(repository.StreamSource):
 
1837
    """Stream data from a remote server."""
 
1838
 
 
1839
    def get_stream(self, search):
 
1840
        if (self.from_repository._fallback_repositories and
 
1841
            self.to_format._fetch_order == 'topological'):
 
1842
            return self._real_stream(self.from_repository, search)
 
1843
        sources = []
 
1844
        seen = set()
 
1845
        repos = [self.from_repository]
 
1846
        while repos:
 
1847
            repo = repos.pop(0)
 
1848
            if repo in seen:
 
1849
                continue
 
1850
            seen.add(repo)
 
1851
            repos.extend(repo._fallback_repositories)
 
1852
            sources.append(repo)
 
1853
        return self.missing_parents_chain(search, sources)
 
1854
 
 
1855
    def get_stream_for_missing_keys(self, missing_keys):
 
1856
        self.from_repository._ensure_real()
 
1857
        real_repo = self.from_repository._real_repository
 
1858
        real_source = real_repo._get_source(self.to_format)
 
1859
        return real_source.get_stream_for_missing_keys(missing_keys)
 
1860
 
 
1861
    def _real_stream(self, repo, search):
 
1862
        """Get a stream for search from repo.
 
1863
        
 
1864
        This never called RemoteStreamSource.get_stream, and is a heler
 
1865
        for RemoteStreamSource._get_stream to allow getting a stream 
 
1866
        reliably whether fallback back because of old servers or trying
 
1867
        to stream from a non-RemoteRepository (which the stacked support
 
1868
        code will do).
 
1869
        """
 
1870
        source = repo._get_source(self.to_format)
 
1871
        if isinstance(source, RemoteStreamSource):
 
1872
            repo._ensure_real()
 
1873
            source = repo._real_repository._get_source(self.to_format)
 
1874
        return source.get_stream(search)
 
1875
 
 
1876
    def _get_stream(self, repo, search):
 
1877
        """Core worker to get a stream from repo for search.
 
1878
 
 
1879
        This is used by both get_stream and the stacking support logic. It
 
1880
        deliberately gets a stream for repo which does not need to be
 
1881
        self.from_repository. In the event that repo is not Remote, or
 
1882
        cannot do a smart stream, a fallback is made to the generic
 
1883
        repository._get_stream() interface, via self._real_stream.
 
1884
 
 
1885
        In the event of stacking, streams from _get_stream will not
 
1886
        contain all the data for search - this is normal (see get_stream).
 
1887
 
 
1888
        :param repo: A repository.
 
1889
        :param search: A search.
 
1890
        """
 
1891
        # Fallbacks may be non-smart
 
1892
        if not isinstance(repo, RemoteRepository):
 
1893
            return self._real_stream(repo, search)
 
1894
        client = repo._client
 
1895
        medium = client._medium
 
1896
        path = repo.bzrdir._path_for_remote_call(client)
 
1897
        search_bytes = repo._serialise_search_result(search)
 
1898
        args = (path, self.to_format.network_name())
 
1899
        candidate_verbs = [
 
1900
            ('Repository.get_stream_1.19', (1, 19)),
 
1901
            ('Repository.get_stream', (1, 13))]
 
1902
        found_verb = False
 
1903
        for verb, version in candidate_verbs:
 
1904
            if medium._is_remote_before(version):
 
1905
                continue
 
1906
            try:
 
1907
                response = repo._call_with_body_bytes_expecting_body(
 
1908
                    verb, args, search_bytes)
 
1909
            except errors.UnknownSmartMethod:
 
1910
                medium._remember_remote_is_before(version)
 
1911
            else:
 
1912
                response_tuple, response_handler = response
 
1913
                found_verb = True
 
1914
                break
 
1915
        if not found_verb:
 
1916
            return self._real_stream(repo, search)
 
1917
        if response_tuple[0] != 'ok':
 
1918
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
1919
        byte_stream = response_handler.read_streamed_body()
 
1920
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
 
1921
        if src_format.network_name() != repo._format.network_name():
 
1922
            raise AssertionError(
 
1923
                "Mismatched RemoteRepository and stream src %r, %r" % (
 
1924
                src_format.network_name(), repo._format.network_name()))
 
1925
        return stream
 
1926
 
 
1927
    def missing_parents_chain(self, search, sources):
 
1928
        """Chain multiple streams together to handle stacking.
 
1929
 
 
1930
        :param search: The overall search to satisfy with streams.
 
1931
        :param sources: A list of Repository objects to query.
 
1932
        """
 
1933
        self.from_serialiser = self.from_repository._format._serializer
 
1934
        self.seen_revs = set()
 
1935
        self.referenced_revs = set()
 
1936
        # If there are heads in the search, or the key count is > 0, we are not
 
1937
        # done.
 
1938
        while not search.is_empty() and len(sources) > 1:
 
1939
            source = sources.pop(0)
 
1940
            stream = self._get_stream(source, search)
 
1941
            for kind, substream in stream:
 
1942
                if kind != 'revisions':
 
1943
                    yield kind, substream
 
1944
                else:
 
1945
                    yield kind, self.missing_parents_rev_handler(substream)
 
1946
            search = search.refine(self.seen_revs, self.referenced_revs)
 
1947
            self.seen_revs = set()
 
1948
            self.referenced_revs = set()
 
1949
        if not search.is_empty():
 
1950
            for kind, stream in self._get_stream(sources[0], search):
 
1951
                yield kind, stream
 
1952
 
 
1953
    def missing_parents_rev_handler(self, substream):
 
1954
        for content in substream:
 
1955
            revision_bytes = content.get_bytes_as('fulltext')
 
1956
            revision = self.from_serialiser.read_revision_from_string(
 
1957
                revision_bytes)
 
1958
            self.seen_revs.add(content.key[-1])
 
1959
            self.referenced_revs.update(revision.parent_ids)
 
1960
            yield content
 
1961
 
 
1962
 
 
1963
class RemoteBranchLockableFiles(LockableFiles):
 
1964
    """A 'LockableFiles' implementation that talks to a smart server.
 
1965
 
 
1966
    This is not a public interface class.
 
1967
    """
 
1968
 
 
1969
    def __init__(self, bzrdir, _client):
 
1970
        self.bzrdir = bzrdir
 
1971
        self._client = _client
 
1972
        self._need_find_modes = True
 
1973
        LockableFiles.__init__(
 
1974
            self, bzrdir.get_branch_transport(None),
 
1975
            'lock', lockdir.LockDir)
 
1976
 
 
1977
    def _find_modes(self):
 
1978
        # RemoteBranches don't let the client set the mode of control files.
 
1979
        self._dir_mode = None
 
1980
        self._file_mode = None
 
1981
 
 
1982
 
 
1983
class RemoteBranchFormat(branch.BranchFormat):
 
1984
 
 
1985
    def __init__(self, network_name=None):
 
1986
        super(RemoteBranchFormat, self).__init__()
 
1987
        self._matchingbzrdir = RemoteBzrDirFormat()
 
1988
        self._matchingbzrdir.set_branch_format(self)
 
1989
        self._custom_format = None
 
1990
        self._network_name = network_name
 
1991
 
 
1992
    def __eq__(self, other):
 
1993
        return (isinstance(other, RemoteBranchFormat) and
 
1994
            self.__dict__ == other.__dict__)
 
1995
 
 
1996
    def _ensure_real(self):
 
1997
        if self._custom_format is None:
 
1998
            self._custom_format = branch.network_format_registry.get(
 
1999
                self._network_name)
 
2000
 
 
2001
    def get_format_description(self):
 
2002
        return 'Remote BZR Branch'
 
2003
 
 
2004
    def network_name(self):
 
2005
        return self._network_name
 
2006
 
 
2007
    def open(self, a_bzrdir, ignore_fallbacks=False):
 
2008
        return a_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
 
2009
 
 
2010
    def _vfs_initialize(self, a_bzrdir):
 
2011
        # Initialisation when using a local bzrdir object, or a non-vfs init
 
2012
        # method is not available on the server.
 
2013
        # self._custom_format is always set - the start of initialize ensures
 
2014
        # that.
 
2015
        if isinstance(a_bzrdir, RemoteBzrDir):
 
2016
            a_bzrdir._ensure_real()
 
2017
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir)
 
2018
        else:
 
2019
            # We assume the bzrdir is parameterised; it may not be.
 
2020
            result = self._custom_format.initialize(a_bzrdir)
 
2021
        if (isinstance(a_bzrdir, RemoteBzrDir) and
 
2022
            not isinstance(result, RemoteBranch)):
 
2023
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result)
 
2024
        return result
 
2025
 
 
2026
    def initialize(self, a_bzrdir):
 
2027
        # 1) get the network name to use.
 
2028
        if self._custom_format:
 
2029
            network_name = self._custom_format.network_name()
 
2030
        else:
 
2031
            # Select the current bzrlib default and ask for that.
 
2032
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
2033
            reference_format = reference_bzrdir_format.get_branch_format()
 
2034
            self._custom_format = reference_format
 
2035
            network_name = reference_format.network_name()
 
2036
        # Being asked to create on a non RemoteBzrDir:
 
2037
        if not isinstance(a_bzrdir, RemoteBzrDir):
 
2038
            return self._vfs_initialize(a_bzrdir)
 
2039
        medium = a_bzrdir._client._medium
 
2040
        if medium._is_remote_before((1, 13)):
 
2041
            return self._vfs_initialize(a_bzrdir)
 
2042
        # Creating on a remote bzr dir.
 
2043
        # 2) try direct creation via RPC
 
2044
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
 
2045
        verb = 'BzrDir.create_branch'
 
2046
        try:
 
2047
            response = a_bzrdir._call(verb, path, network_name)
 
2048
        except errors.UnknownSmartMethod:
 
2049
            # Fallback - use vfs methods
 
2050
            medium._remember_remote_is_before((1, 13))
 
2051
            return self._vfs_initialize(a_bzrdir)
 
2052
        if response[0] != 'ok':
 
2053
            raise errors.UnexpectedSmartServerResponse(response)
 
2054
        # Turn the response into a RemoteRepository object.
 
2055
        format = RemoteBranchFormat(network_name=response[1])
 
2056
        repo_format = response_tuple_to_repo_format(response[3:])
 
2057
        if response[2] == '':
 
2058
            repo_bzrdir = a_bzrdir
 
2059
        else:
 
2060
            repo_bzrdir = RemoteBzrDir(
 
2061
                a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
 
2062
                a_bzrdir._client)
 
2063
        remote_repo = RemoteRepository(repo_bzrdir, repo_format)
 
2064
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
 
2065
            format=format, setup_stacking=False)
 
2066
        # XXX: We know this is a new branch, so it must have revno 0, revid
 
2067
        # NULL_REVISION. Creating the branch locked would make this be unable
 
2068
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
 
2069
        remote_branch._last_revision_info_cache = 0, NULL_REVISION
 
2070
        return remote_branch
 
2071
 
 
2072
    def make_tags(self, branch):
 
2073
        self._ensure_real()
 
2074
        return self._custom_format.make_tags(branch)
 
2075
 
 
2076
    def supports_tags(self):
 
2077
        # Remote branches might support tags, but we won't know until we
 
2078
        # access the real remote branch.
 
2079
        self._ensure_real()
 
2080
        return self._custom_format.supports_tags()
 
2081
 
 
2082
    def supports_stacking(self):
 
2083
        self._ensure_real()
 
2084
        return self._custom_format.supports_stacking()
 
2085
 
 
2086
    def supports_set_append_revisions_only(self):
 
2087
        self._ensure_real()
 
2088
        return self._custom_format.supports_set_append_revisions_only()
 
2089
 
 
2090
 
 
2091
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
 
2092
    """Branch stored on a server accessed by HPSS RPC.
 
2093
 
 
2094
    At the moment most operations are mapped down to simple file operations.
 
2095
    """
 
2096
 
 
2097
    def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
 
2098
        _client=None, format=None, setup_stacking=True):
 
2099
        """Create a RemoteBranch instance.
 
2100
 
 
2101
        :param real_branch: An optional local implementation of the branch
 
2102
            format, usually accessing the data via the VFS.
 
2103
        :param _client: Private parameter for testing.
 
2104
        :param format: A RemoteBranchFormat object, None to create one
 
2105
            automatically. If supplied it should have a network_name already
 
2106
            supplied.
 
2107
        :param setup_stacking: If True make an RPC call to determine the
 
2108
            stacked (or not) status of the branch. If False assume the branch
 
2109
            is not stacked.
 
2110
        """
 
2111
        # We intentionally don't call the parent class's __init__, because it
 
2112
        # will try to assign to self.tags, which is a property in this subclass.
 
2113
        # And the parent's __init__ doesn't do much anyway.
 
2114
        self.bzrdir = remote_bzrdir
 
2115
        if _client is not None:
 
2116
            self._client = _client
 
2117
        else:
 
2118
            self._client = remote_bzrdir._client
 
2119
        self.repository = remote_repository
 
2120
        if real_branch is not None:
 
2121
            self._real_branch = real_branch
 
2122
            # Give the remote repository the matching real repo.
 
2123
            real_repo = self._real_branch.repository
 
2124
            if isinstance(real_repo, RemoteRepository):
 
2125
                real_repo._ensure_real()
 
2126
                real_repo = real_repo._real_repository
 
2127
            self.repository._set_real_repository(real_repo)
 
2128
            # Give the branch the remote repository to let fast-pathing happen.
 
2129
            self._real_branch.repository = self.repository
 
2130
        else:
 
2131
            self._real_branch = None
 
2132
        # Fill out expected attributes of branch for bzrlib API users.
 
2133
        self._clear_cached_state()
 
2134
        self.base = self.bzrdir.root_transport.base
 
2135
        self._control_files = None
 
2136
        self._lock_mode = None
 
2137
        self._lock_token = None
 
2138
        self._repo_lock_token = None
 
2139
        self._lock_count = 0
 
2140
        self._leave_lock = False
 
2141
        # Setup a format: note that we cannot call _ensure_real until all the
 
2142
        # attributes above are set: This code cannot be moved higher up in this
 
2143
        # function.
 
2144
        if format is None:
 
2145
            self._format = RemoteBranchFormat()
 
2146
            if real_branch is not None:
 
2147
                self._format._network_name = \
 
2148
                    self._real_branch._format.network_name()
 
2149
        else:
 
2150
            self._format = format
 
2151
        # when we do _ensure_real we may need to pass ignore_fallbacks to the
 
2152
        # branch.open_branch method.
 
2153
        self._real_ignore_fallbacks = not setup_stacking
 
2154
        if not self._format._network_name:
 
2155
            # Did not get from open_branchV2 - old server.
 
2156
            self._ensure_real()
 
2157
            self._format._network_name = \
 
2158
                self._real_branch._format.network_name()
 
2159
        self.tags = self._format.make_tags(self)
 
2160
        # The base class init is not called, so we duplicate this:
 
2161
        hooks = branch.Branch.hooks['open']
 
2162
        for hook in hooks:
 
2163
            hook(self)
 
2164
        self._is_stacked = False
 
2165
        if setup_stacking:
 
2166
            self._setup_stacking()
 
2167
 
 
2168
    def _setup_stacking(self):
 
2169
        # configure stacking into the remote repository, by reading it from
 
2170
        # the vfs branch.
 
2171
        try:
 
2172
            fallback_url = self.get_stacked_on_url()
 
2173
        except (errors.NotStacked, errors.UnstackableBranchFormat,
 
2174
            errors.UnstackableRepositoryFormat), e:
 
2175
            return
 
2176
        self._is_stacked = True
 
2177
        self._activate_fallback_location(fallback_url)
 
2178
 
 
2179
    def _get_config(self):
 
2180
        return RemoteBranchConfig(self)
 
2181
 
 
2182
    def _get_real_transport(self):
 
2183
        # if we try vfs access, return the real branch's vfs transport
 
2184
        self._ensure_real()
 
2185
        return self._real_branch._transport
 
2186
 
 
2187
    _transport = property(_get_real_transport)
 
2188
 
 
2189
    def __str__(self):
 
2190
        return "%s(%s)" % (self.__class__.__name__, self.base)
 
2191
 
 
2192
    __repr__ = __str__
 
2193
 
 
2194
    def _ensure_real(self):
 
2195
        """Ensure that there is a _real_branch set.
 
2196
 
 
2197
        Used before calls to self._real_branch.
 
2198
        """
 
2199
        if self._real_branch is None:
 
2200
            if not vfs.vfs_enabled():
 
2201
                raise AssertionError('smart server vfs must be enabled '
 
2202
                    'to use vfs implementation')
 
2203
            self.bzrdir._ensure_real()
 
2204
            self._real_branch = self.bzrdir._real_bzrdir.open_branch(
 
2205
                ignore_fallbacks=self._real_ignore_fallbacks)
 
2206
            if self.repository._real_repository is None:
 
2207
                # Give the remote repository the matching real repo.
 
2208
                real_repo = self._real_branch.repository
 
2209
                if isinstance(real_repo, RemoteRepository):
 
2210
                    real_repo._ensure_real()
 
2211
                    real_repo = real_repo._real_repository
 
2212
                self.repository._set_real_repository(real_repo)
 
2213
            # Give the real branch the remote repository to let fast-pathing
 
2214
            # happen.
 
2215
            self._real_branch.repository = self.repository
 
2216
            if self._lock_mode == 'r':
 
2217
                self._real_branch.lock_read()
 
2218
            elif self._lock_mode == 'w':
 
2219
                self._real_branch.lock_write(token=self._lock_token)
 
2220
 
 
2221
    def _translate_error(self, err, **context):
 
2222
        self.repository._translate_error(err, branch=self, **context)
 
2223
 
 
2224
    def _clear_cached_state(self):
 
2225
        super(RemoteBranch, self)._clear_cached_state()
 
2226
        if self._real_branch is not None:
 
2227
            self._real_branch._clear_cached_state()
 
2228
 
 
2229
    def _clear_cached_state_of_remote_branch_only(self):
 
2230
        """Like _clear_cached_state, but doesn't clear the cache of
 
2231
        self._real_branch.
 
2232
 
 
2233
        This is useful when falling back to calling a method of
 
2234
        self._real_branch that changes state.  In that case the underlying
 
2235
        branch changes, so we need to invalidate this RemoteBranch's cache of
 
2236
        it.  However, there's no need to invalidate the _real_branch's cache
 
2237
        too, in fact doing so might harm performance.
 
2238
        """
 
2239
        super(RemoteBranch, self)._clear_cached_state()
 
2240
 
 
2241
    @property
 
2242
    def control_files(self):
 
2243
        # Defer actually creating RemoteBranchLockableFiles until its needed,
 
2244
        # because it triggers an _ensure_real that we otherwise might not need.
 
2245
        if self._control_files is None:
 
2246
            self._control_files = RemoteBranchLockableFiles(
 
2247
                self.bzrdir, self._client)
 
2248
        return self._control_files
 
2249
 
 
2250
    def _get_checkout_format(self):
 
2251
        self._ensure_real()
 
2252
        return self._real_branch._get_checkout_format()
 
2253
 
 
2254
    def get_physical_lock_status(self):
 
2255
        """See Branch.get_physical_lock_status()."""
 
2256
        # should be an API call to the server, as branches must be lockable.
 
2257
        self._ensure_real()
 
2258
        return self._real_branch.get_physical_lock_status()
 
2259
 
 
2260
    def get_stacked_on_url(self):
 
2261
        """Get the URL this branch is stacked against.
 
2262
 
 
2263
        :raises NotStacked: If the branch is not stacked.
 
2264
        :raises UnstackableBranchFormat: If the branch does not support
 
2265
            stacking.
 
2266
        :raises UnstackableRepositoryFormat: If the repository does not support
 
2267
            stacking.
 
2268
        """
 
2269
        try:
 
2270
            # there may not be a repository yet, so we can't use
 
2271
            # self._translate_error, so we can't use self._call either.
 
2272
            response = self._client.call('Branch.get_stacked_on_url',
 
2273
                self._remote_path())
 
2274
        except errors.ErrorFromSmartServer, err:
 
2275
            # there may not be a repository yet, so we can't call through
 
2276
            # its _translate_error
 
2277
            _translate_error(err, branch=self)
 
2278
        except errors.UnknownSmartMethod, err:
 
2279
            self._ensure_real()
 
2280
            return self._real_branch.get_stacked_on_url()
 
2281
        if response[0] != 'ok':
 
2282
            raise errors.UnexpectedSmartServerResponse(response)
 
2283
        return response[1]
 
2284
 
 
2285
    def set_stacked_on_url(self, url):
 
2286
        branch.Branch.set_stacked_on_url(self, url)
 
2287
        if not url:
 
2288
            self._is_stacked = False
 
2289
        else:
 
2290
            self._is_stacked = True
 
2291
        
 
2292
    def _vfs_get_tags_bytes(self):
 
2293
        self._ensure_real()
 
2294
        return self._real_branch._get_tags_bytes()
 
2295
 
 
2296
    def _get_tags_bytes(self):
 
2297
        medium = self._client._medium
 
2298
        if medium._is_remote_before((1, 13)):
 
2299
            return self._vfs_get_tags_bytes()
 
2300
        try:
 
2301
            response = self._call('Branch.get_tags_bytes', self._remote_path())
 
2302
        except errors.UnknownSmartMethod:
 
2303
            medium._remember_remote_is_before((1, 13))
 
2304
            return self._vfs_get_tags_bytes()
 
2305
        return response[0]
 
2306
 
 
2307
    def _vfs_set_tags_bytes(self, bytes):
 
2308
        self._ensure_real()
 
2309
        return self._real_branch._set_tags_bytes(bytes)
 
2310
 
 
2311
    def _set_tags_bytes(self, bytes):
 
2312
        medium = self._client._medium
 
2313
        if medium._is_remote_before((1, 18)):
 
2314
            self._vfs_set_tags_bytes(bytes)
 
2315
            return
 
2316
        try:
 
2317
            args = (
 
2318
                self._remote_path(), self._lock_token, self._repo_lock_token)
 
2319
            response = self._call_with_body_bytes(
 
2320
                'Branch.set_tags_bytes', args, bytes)
 
2321
        except errors.UnknownSmartMethod:
 
2322
            medium._remember_remote_is_before((1, 18))
 
2323
            self._vfs_set_tags_bytes(bytes)
 
2324
 
 
2325
    def lock_read(self):
 
2326
        self.repository.lock_read()
 
2327
        if not self._lock_mode:
 
2328
            self._note_lock('r')
 
2329
            self._lock_mode = 'r'
 
2330
            self._lock_count = 1
 
2331
            if self._real_branch is not None:
 
2332
                self._real_branch.lock_read()
 
2333
        else:
 
2334
            self._lock_count += 1
 
2335
 
 
2336
    def _remote_lock_write(self, token):
 
2337
        if token is None:
 
2338
            branch_token = repo_token = ''
 
2339
        else:
 
2340
            branch_token = token
 
2341
            repo_token = self.repository.lock_write()
 
2342
            self.repository.unlock()
 
2343
        err_context = {'token': token}
 
2344
        response = self._call(
 
2345
            'Branch.lock_write', self._remote_path(), branch_token,
 
2346
            repo_token or '', **err_context)
 
2347
        if response[0] != 'ok':
 
2348
            raise errors.UnexpectedSmartServerResponse(response)
 
2349
        ok, branch_token, repo_token = response
 
2350
        return branch_token, repo_token
 
2351
 
 
2352
    def lock_write(self, token=None):
 
2353
        if not self._lock_mode:
 
2354
            self._note_lock('w')
 
2355
            # Lock the branch and repo in one remote call.
 
2356
            remote_tokens = self._remote_lock_write(token)
 
2357
            self._lock_token, self._repo_lock_token = remote_tokens
 
2358
            if not self._lock_token:
 
2359
                raise SmartProtocolError('Remote server did not return a token!')
 
2360
            # Tell the self.repository object that it is locked.
 
2361
            self.repository.lock_write(
 
2362
                self._repo_lock_token, _skip_rpc=True)
 
2363
 
 
2364
            if self._real_branch is not None:
 
2365
                self._real_branch.lock_write(token=self._lock_token)
 
2366
            if token is not None:
 
2367
                self._leave_lock = True
 
2368
            else:
 
2369
                self._leave_lock = False
 
2370
            self._lock_mode = 'w'
 
2371
            self._lock_count = 1
 
2372
        elif self._lock_mode == 'r':
 
2373
            raise errors.ReadOnlyTransaction
 
2374
        else:
 
2375
            if token is not None:
 
2376
                # A token was given to lock_write, and we're relocking, so
 
2377
                # check that the given token actually matches the one we
 
2378
                # already have.
 
2379
                if token != self._lock_token:
 
2380
                    raise errors.TokenMismatch(token, self._lock_token)
 
2381
            self._lock_count += 1
 
2382
            # Re-lock the repository too.
 
2383
            self.repository.lock_write(self._repo_lock_token)
 
2384
        return self._lock_token or None
 
2385
 
 
2386
    def _unlock(self, branch_token, repo_token):
 
2387
        err_context = {'token': str((branch_token, repo_token))}
 
2388
        response = self._call(
 
2389
            'Branch.unlock', self._remote_path(), branch_token,
 
2390
            repo_token or '', **err_context)
 
2391
        if response == ('ok',):
 
2392
            return
 
2393
        raise errors.UnexpectedSmartServerResponse(response)
 
2394
 
 
2395
    @only_raises(errors.LockNotHeld, errors.LockBroken)
 
2396
    def unlock(self):
 
2397
        try:
 
2398
            self._lock_count -= 1
 
2399
            if not self._lock_count:
 
2400
                self._clear_cached_state()
 
2401
                mode = self._lock_mode
 
2402
                self._lock_mode = None
 
2403
                if self._real_branch is not None:
 
2404
                    if (not self._leave_lock and mode == 'w' and
 
2405
                        self._repo_lock_token):
 
2406
                        # If this RemoteBranch will remove the physical lock
 
2407
                        # for the repository, make sure the _real_branch
 
2408
                        # doesn't do it first.  (Because the _real_branch's
 
2409
                        # repository is set to be the RemoteRepository.)
 
2410
                        self._real_branch.repository.leave_lock_in_place()
 
2411
                    self._real_branch.unlock()
 
2412
                if mode != 'w':
 
2413
                    # Only write-locked branched need to make a remote method
 
2414
                    # call to perform the unlock.
 
2415
                    return
 
2416
                if not self._lock_token:
 
2417
                    raise AssertionError('Locked, but no token!')
 
2418
                branch_token = self._lock_token
 
2419
                repo_token = self._repo_lock_token
 
2420
                self._lock_token = None
 
2421
                self._repo_lock_token = None
 
2422
                if not self._leave_lock:
 
2423
                    self._unlock(branch_token, repo_token)
 
2424
        finally:
 
2425
            self.repository.unlock()
 
2426
 
 
2427
    def break_lock(self):
 
2428
        self._ensure_real()
 
2429
        return self._real_branch.break_lock()
 
2430
 
 
2431
    def leave_lock_in_place(self):
 
2432
        if not self._lock_token:
 
2433
            raise NotImplementedError(self.leave_lock_in_place)
 
2434
        self._leave_lock = True
 
2435
 
 
2436
    def dont_leave_lock_in_place(self):
 
2437
        if not self._lock_token:
 
2438
            raise NotImplementedError(self.dont_leave_lock_in_place)
 
2439
        self._leave_lock = False
 
2440
 
 
2441
    @needs_read_lock
 
2442
    def get_rev_id(self, revno, history=None):
 
2443
        if revno == 0:
 
2444
            return _mod_revision.NULL_REVISION
 
2445
        last_revision_info = self.last_revision_info()
 
2446
        ok, result = self.repository.get_rev_id_for_revno(
 
2447
            revno, last_revision_info)
 
2448
        if ok:
 
2449
            return result
 
2450
        missing_parent = result[1]
 
2451
        # Either the revision named by the server is missing, or its parent
 
2452
        # is.  Call get_parent_map to determine which, so that we report a
 
2453
        # useful error.
 
2454
        parent_map = self.repository.get_parent_map([missing_parent])
 
2455
        if missing_parent in parent_map:
 
2456
            missing_parent = parent_map[missing_parent]
 
2457
        raise errors.RevisionNotPresent(missing_parent, self.repository)
 
2458
 
 
2459
    def _last_revision_info(self):
 
2460
        response = self._call('Branch.last_revision_info', self._remote_path())
 
2461
        if response[0] != 'ok':
 
2462
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
2463
        revno = int(response[1])
 
2464
        last_revision = response[2]
 
2465
        return (revno, last_revision)
 
2466
 
 
2467
    def _gen_revision_history(self):
 
2468
        """See Branch._gen_revision_history()."""
 
2469
        if self._is_stacked:
 
2470
            self._ensure_real()
 
2471
            return self._real_branch._gen_revision_history()
 
2472
        response_tuple, response_handler = self._call_expecting_body(
 
2473
            'Branch.revision_history', self._remote_path())
 
2474
        if response_tuple[0] != 'ok':
 
2475
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2476
        result = response_handler.read_body_bytes().split('\x00')
 
2477
        if result == ['']:
 
2478
            return []
 
2479
        return result
 
2480
 
 
2481
    def _remote_path(self):
 
2482
        return self.bzrdir._path_for_remote_call(self._client)
 
2483
 
 
2484
    def _set_last_revision_descendant(self, revision_id, other_branch,
 
2485
            allow_diverged=False, allow_overwrite_descendant=False):
 
2486
        # This performs additional work to meet the hook contract; while its
 
2487
        # undesirable, we have to synthesise the revno to call the hook, and
 
2488
        # not calling the hook is worse as it means changes can't be prevented.
 
2489
        # Having calculated this though, we can't just call into
 
2490
        # set_last_revision_info as a simple call, because there is a set_rh
 
2491
        # hook that some folk may still be using.
 
2492
        old_revno, old_revid = self.last_revision_info()
 
2493
        history = self._lefthand_history(revision_id)
 
2494
        self._run_pre_change_branch_tip_hooks(len(history), revision_id)
 
2495
        err_context = {'other_branch': other_branch}
 
2496
        response = self._call('Branch.set_last_revision_ex',
 
2497
            self._remote_path(), self._lock_token, self._repo_lock_token,
 
2498
            revision_id, int(allow_diverged), int(allow_overwrite_descendant),
 
2499
            **err_context)
 
2500
        self._clear_cached_state()
 
2501
        if len(response) != 3 and response[0] != 'ok':
 
2502
            raise errors.UnexpectedSmartServerResponse(response)
 
2503
        new_revno, new_revision_id = response[1:]
 
2504
        self._last_revision_info_cache = new_revno, new_revision_id
 
2505
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
 
2506
        if self._real_branch is not None:
 
2507
            cache = new_revno, new_revision_id
 
2508
            self._real_branch._last_revision_info_cache = cache
 
2509
 
 
2510
    def _set_last_revision(self, revision_id):
 
2511
        old_revno, old_revid = self.last_revision_info()
 
2512
        # This performs additional work to meet the hook contract; while its
 
2513
        # undesirable, we have to synthesise the revno to call the hook, and
 
2514
        # not calling the hook is worse as it means changes can't be prevented.
 
2515
        # Having calculated this though, we can't just call into
 
2516
        # set_last_revision_info as a simple call, because there is a set_rh
 
2517
        # hook that some folk may still be using.
 
2518
        history = self._lefthand_history(revision_id)
 
2519
        self._run_pre_change_branch_tip_hooks(len(history), revision_id)
 
2520
        self._clear_cached_state()
 
2521
        response = self._call('Branch.set_last_revision',
 
2522
            self._remote_path(), self._lock_token, self._repo_lock_token,
 
2523
            revision_id)
 
2524
        if response != ('ok',):
 
2525
            raise errors.UnexpectedSmartServerResponse(response)
 
2526
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
 
2527
 
 
2528
    @needs_write_lock
 
2529
    def set_revision_history(self, rev_history):
 
2530
        # Send just the tip revision of the history; the server will generate
 
2531
        # the full history from that.  If the revision doesn't exist in this
 
2532
        # branch, NoSuchRevision will be raised.
 
2533
        if rev_history == []:
 
2534
            rev_id = 'null:'
 
2535
        else:
 
2536
            rev_id = rev_history[-1]
 
2537
        self._set_last_revision(rev_id)
 
2538
        for hook in branch.Branch.hooks['set_rh']:
 
2539
            hook(self, rev_history)
 
2540
        self._cache_revision_history(rev_history)
 
2541
 
 
2542
    def _get_parent_location(self):
 
2543
        medium = self._client._medium
 
2544
        if medium._is_remote_before((1, 13)):
 
2545
            return self._vfs_get_parent_location()
 
2546
        try:
 
2547
            response = self._call('Branch.get_parent', self._remote_path())
 
2548
        except errors.UnknownSmartMethod:
 
2549
            medium._remember_remote_is_before((1, 13))
 
2550
            return self._vfs_get_parent_location()
 
2551
        if len(response) != 1:
 
2552
            raise errors.UnexpectedSmartServerResponse(response)
 
2553
        parent_location = response[0]
 
2554
        if parent_location == '':
 
2555
            return None
 
2556
        return parent_location
 
2557
 
 
2558
    def _vfs_get_parent_location(self):
 
2559
        self._ensure_real()
 
2560
        return self._real_branch._get_parent_location()
 
2561
 
 
2562
    def _set_parent_location(self, url):
 
2563
        medium = self._client._medium
 
2564
        if medium._is_remote_before((1, 15)):
 
2565
            return self._vfs_set_parent_location(url)
 
2566
        try:
 
2567
            call_url = url or ''
 
2568
            if type(call_url) is not str:
 
2569
                raise AssertionError('url must be a str or None (%s)' % url)
 
2570
            response = self._call('Branch.set_parent_location',
 
2571
                self._remote_path(), self._lock_token, self._repo_lock_token,
 
2572
                call_url)
 
2573
        except errors.UnknownSmartMethod:
 
2574
            medium._remember_remote_is_before((1, 15))
 
2575
            return self._vfs_set_parent_location(url)
 
2576
        if response != ():
 
2577
            raise errors.UnexpectedSmartServerResponse(response)
 
2578
 
 
2579
    def _vfs_set_parent_location(self, url):
 
2580
        self._ensure_real()
 
2581
        return self._real_branch._set_parent_location(url)
 
2582
 
 
2583
    @needs_write_lock
 
2584
    def pull(self, source, overwrite=False, stop_revision=None,
 
2585
             **kwargs):
 
2586
        self._clear_cached_state_of_remote_branch_only()
 
2587
        self._ensure_real()
 
2588
        return self._real_branch.pull(
 
2589
            source, overwrite=overwrite, stop_revision=stop_revision,
 
2590
            _override_hook_target=self, **kwargs)
 
2591
 
 
2592
    @needs_read_lock
 
2593
    def push(self, target, overwrite=False, stop_revision=None):
 
2594
        self._ensure_real()
 
2595
        return self._real_branch.push(
 
2596
            target, overwrite=overwrite, stop_revision=stop_revision,
 
2597
            _override_hook_source_branch=self)
 
2598
 
 
2599
    def is_locked(self):
 
2600
        return self._lock_count >= 1
 
2601
 
 
2602
    @needs_read_lock
 
2603
    def revision_id_to_revno(self, revision_id):
 
2604
        self._ensure_real()
 
2605
        return self._real_branch.revision_id_to_revno(revision_id)
 
2606
 
 
2607
    @needs_write_lock
 
2608
    def set_last_revision_info(self, revno, revision_id):
 
2609
        # XXX: These should be returned by the set_last_revision_info verb
 
2610
        old_revno, old_revid = self.last_revision_info()
 
2611
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
 
2612
        revision_id = ensure_null(revision_id)
 
2613
        try:
 
2614
            response = self._call('Branch.set_last_revision_info',
 
2615
                self._remote_path(), self._lock_token, self._repo_lock_token,
 
2616
                str(revno), revision_id)
 
2617
        except errors.UnknownSmartMethod:
 
2618
            self._ensure_real()
 
2619
            self._clear_cached_state_of_remote_branch_only()
 
2620
            self._real_branch.set_last_revision_info(revno, revision_id)
 
2621
            self._last_revision_info_cache = revno, revision_id
 
2622
            return
 
2623
        if response == ('ok',):
 
2624
            self._clear_cached_state()
 
2625
            self._last_revision_info_cache = revno, revision_id
 
2626
            self._run_post_change_branch_tip_hooks(old_revno, old_revid)
 
2627
            # Update the _real_branch's cache too.
 
2628
            if self._real_branch is not None:
 
2629
                cache = self._last_revision_info_cache
 
2630
                self._real_branch._last_revision_info_cache = cache
 
2631
        else:
 
2632
            raise errors.UnexpectedSmartServerResponse(response)
 
2633
 
 
2634
    @needs_write_lock
 
2635
    def generate_revision_history(self, revision_id, last_rev=None,
 
2636
                                  other_branch=None):
 
2637
        medium = self._client._medium
 
2638
        if not medium._is_remote_before((1, 6)):
 
2639
            # Use a smart method for 1.6 and above servers
 
2640
            try:
 
2641
                self._set_last_revision_descendant(revision_id, other_branch,
 
2642
                    allow_diverged=True, allow_overwrite_descendant=True)
 
2643
                return
 
2644
            except errors.UnknownSmartMethod:
 
2645
                medium._remember_remote_is_before((1, 6))
 
2646
        self._clear_cached_state_of_remote_branch_only()
 
2647
        self.set_revision_history(self._lefthand_history(revision_id,
 
2648
            last_rev=last_rev,other_branch=other_branch))
 
2649
 
 
2650
    def set_push_location(self, location):
 
2651
        self._ensure_real()
 
2652
        return self._real_branch.set_push_location(location)
 
2653
 
 
2654
 
 
2655
class RemoteConfig(object):
 
2656
    """A Config that reads and writes from smart verbs.
 
2657
 
 
2658
    It is a low-level object that considers config data to be name/value pairs
 
2659
    that may be associated with a section. Assigning meaning to the these
 
2660
    values is done at higher levels like bzrlib.config.TreeConfig.
 
2661
    """
 
2662
 
 
2663
    def get_option(self, name, section=None, default=None):
 
2664
        """Return the value associated with a named option.
 
2665
 
 
2666
        :param name: The name of the value
 
2667
        :param section: The section the option is in (if any)
 
2668
        :param default: The value to return if the value is not set
 
2669
        :return: The value or default value
 
2670
        """
 
2671
        try:
 
2672
            configobj = self._get_configobj()
 
2673
            if section is None:
 
2674
                section_obj = configobj
 
2675
            else:
 
2676
                try:
 
2677
                    section_obj = configobj[section]
 
2678
                except KeyError:
 
2679
                    return default
 
2680
            return section_obj.get(name, default)
 
2681
        except errors.UnknownSmartMethod:
 
2682
            return self._vfs_get_option(name, section, default)
 
2683
 
 
2684
    def _response_to_configobj(self, response):
 
2685
        if len(response[0]) and response[0][0] != 'ok':
 
2686
            raise errors.UnexpectedSmartServerResponse(response)
 
2687
        lines = response[1].read_body_bytes().splitlines()
 
2688
        return config.ConfigObj(lines, encoding='utf-8')
 
2689
 
 
2690
 
 
2691
class RemoteBranchConfig(RemoteConfig):
 
2692
    """A RemoteConfig for Branches."""
 
2693
 
 
2694
    def __init__(self, branch):
 
2695
        self._branch = branch
 
2696
 
 
2697
    def _get_configobj(self):
 
2698
        path = self._branch._remote_path()
 
2699
        response = self._branch._client.call_expecting_body(
 
2700
            'Branch.get_config_file', path)
 
2701
        return self._response_to_configobj(response)
 
2702
 
 
2703
    def set_option(self, value, name, section=None):
 
2704
        """Set the value associated with a named option.
 
2705
 
 
2706
        :param value: The value to set
 
2707
        :param name: The name of the value to set
 
2708
        :param section: The section the option is in (if any)
 
2709
        """
 
2710
        medium = self._branch._client._medium
 
2711
        if medium._is_remote_before((1, 14)):
 
2712
            return self._vfs_set_option(value, name, section)
 
2713
        try:
 
2714
            path = self._branch._remote_path()
 
2715
            response = self._branch._client.call('Branch.set_config_option',
 
2716
                path, self._branch._lock_token, self._branch._repo_lock_token,
 
2717
                value.encode('utf8'), name, section or '')
 
2718
        except errors.UnknownSmartMethod:
 
2719
            medium._remember_remote_is_before((1, 14))
 
2720
            return self._vfs_set_option(value, name, section)
 
2721
        if response != ():
 
2722
            raise errors.UnexpectedSmartServerResponse(response)
 
2723
 
 
2724
    def _real_object(self):
 
2725
        self._branch._ensure_real()
 
2726
        return self._branch._real_branch
 
2727
 
 
2728
    def _vfs_set_option(self, value, name, section=None):
 
2729
        return self._real_object()._get_config().set_option(
 
2730
            value, name, section)
 
2731
 
 
2732
 
 
2733
class RemoteBzrDirConfig(RemoteConfig):
 
2734
    """A RemoteConfig for BzrDirs."""
 
2735
 
 
2736
    def __init__(self, bzrdir):
 
2737
        self._bzrdir = bzrdir
 
2738
 
 
2739
    def _get_configobj(self):
 
2740
        medium = self._bzrdir._client._medium
 
2741
        verb = 'BzrDir.get_config_file'
 
2742
        if medium._is_remote_before((1, 15)):
 
2743
            raise errors.UnknownSmartMethod(verb)
 
2744
        path = self._bzrdir._path_for_remote_call(self._bzrdir._client)
 
2745
        response = self._bzrdir._call_expecting_body(
 
2746
            verb, path)
 
2747
        return self._response_to_configobj(response)
 
2748
 
 
2749
    def _vfs_get_option(self, name, section, default):
 
2750
        return self._real_object()._get_config().get_option(
 
2751
            name, section, default)
 
2752
 
 
2753
    def set_option(self, value, name, section=None):
 
2754
        """Set the value associated with a named option.
 
2755
 
 
2756
        :param value: The value to set
 
2757
        :param name: The name of the value to set
 
2758
        :param section: The section the option is in (if any)
 
2759
        """
 
2760
        return self._real_object()._get_config().set_option(
 
2761
            value, name, section)
 
2762
 
 
2763
    def _real_object(self):
 
2764
        self._bzrdir._ensure_real()
 
2765
        return self._bzrdir._real_bzrdir
 
2766
 
 
2767
 
 
2768
 
 
2769
def _extract_tar(tar, to_dir):
 
2770
    """Extract all the contents of a tarfile object.
 
2771
 
 
2772
    A replacement for extractall, which is not present in python2.4
 
2773
    """
 
2774
    for tarinfo in tar:
 
2775
        tar.extract(tarinfo, to_dir)
 
2776
 
 
2777
 
 
2778
def _translate_error(err, **context):
 
2779
    """Translate an ErrorFromSmartServer into a more useful error.
 
2780
 
 
2781
    Possible context keys:
 
2782
      - branch
 
2783
      - repository
 
2784
      - bzrdir
 
2785
      - token
 
2786
      - other_branch
 
2787
      - path
 
2788
 
 
2789
    If the error from the server doesn't match a known pattern, then
 
2790
    UnknownErrorFromSmartServer is raised.
 
2791
    """
 
2792
    def find(name):
 
2793
        try:
 
2794
            return context[name]
 
2795
        except KeyError, key_err:
 
2796
            mutter('Missing key %r in context %r', key_err.args[0], context)
 
2797
            raise err
 
2798
    def get_path():
 
2799
        """Get the path from the context if present, otherwise use first error
 
2800
        arg.
 
2801
        """
 
2802
        try:
 
2803
            return context['path']
 
2804
        except KeyError, key_err:
 
2805
            try:
 
2806
                return err.error_args[0]
 
2807
            except IndexError, idx_err:
 
2808
                mutter(
 
2809
                    'Missing key %r in context %r', key_err.args[0], context)
 
2810
                raise err
 
2811
 
 
2812
    if err.error_verb == 'IncompatibleRepositories':
 
2813
        raise errors.IncompatibleRepositories(err.error_args[0],
 
2814
            err.error_args[1], err.error_args[2])
 
2815
    elif err.error_verb == 'NoSuchRevision':
 
2816
        raise NoSuchRevision(find('branch'), err.error_args[0])
 
2817
    elif err.error_verb == 'nosuchrevision':
 
2818
        raise NoSuchRevision(find('repository'), err.error_args[0])
 
2819
    elif err.error_tuple == ('nobranch',):
 
2820
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base)
 
2821
    elif err.error_verb == 'norepository':
 
2822
        raise errors.NoRepositoryPresent(find('bzrdir'))
 
2823
    elif err.error_verb == 'LockContention':
 
2824
        raise errors.LockContention('(remote lock)')
 
2825
    elif err.error_verb == 'UnlockableTransport':
 
2826
        raise errors.UnlockableTransport(find('bzrdir').root_transport)
 
2827
    elif err.error_verb == 'LockFailed':
 
2828
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
 
2829
    elif err.error_verb == 'TokenMismatch':
 
2830
        raise errors.TokenMismatch(find('token'), '(remote token)')
 
2831
    elif err.error_verb == 'Diverged':
 
2832
        raise errors.DivergedBranches(find('branch'), find('other_branch'))
 
2833
    elif err.error_verb == 'TipChangeRejected':
 
2834
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
 
2835
    elif err.error_verb == 'UnstackableBranchFormat':
 
2836
        raise errors.UnstackableBranchFormat(*err.error_args)
 
2837
    elif err.error_verb == 'UnstackableRepositoryFormat':
 
2838
        raise errors.UnstackableRepositoryFormat(*err.error_args)
 
2839
    elif err.error_verb == 'NotStacked':
 
2840
        raise errors.NotStacked(branch=find('branch'))
 
2841
    elif err.error_verb == 'PermissionDenied':
 
2842
        path = get_path()
 
2843
        if len(err.error_args) >= 2:
 
2844
            extra = err.error_args[1]
 
2845
        else:
 
2846
            extra = None
 
2847
        raise errors.PermissionDenied(path, extra=extra)
 
2848
    elif err.error_verb == 'ReadError':
 
2849
        path = get_path()
 
2850
        raise errors.ReadError(path)
 
2851
    elif err.error_verb == 'NoSuchFile':
 
2852
        path = get_path()
 
2853
        raise errors.NoSuchFile(path)
 
2854
    elif err.error_verb == 'FileExists':
 
2855
        raise errors.FileExists(err.error_args[0])
 
2856
    elif err.error_verb == 'DirectoryNotEmpty':
 
2857
        raise errors.DirectoryNotEmpty(err.error_args[0])
 
2858
    elif err.error_verb == 'ShortReadvError':
 
2859
        args = err.error_args
 
2860
        raise errors.ShortReadvError(
 
2861
            args[0], int(args[1]), int(args[2]), int(args[3]))
 
2862
    elif err.error_verb in ('UnicodeEncodeError', 'UnicodeDecodeError'):
 
2863
        encoding = str(err.error_args[0]) # encoding must always be a string
 
2864
        val = err.error_args[1]
 
2865
        start = int(err.error_args[2])
 
2866
        end = int(err.error_args[3])
 
2867
        reason = str(err.error_args[4]) # reason must always be a string
 
2868
        if val.startswith('u:'):
 
2869
            val = val[2:].decode('utf-8')
 
2870
        elif val.startswith('s:'):
 
2871
            val = val[2:].decode('base64')
 
2872
        if err.error_verb == 'UnicodeDecodeError':
 
2873
            raise UnicodeDecodeError(encoding, val, start, end, reason)
 
2874
        elif err.error_verb == 'UnicodeEncodeError':
 
2875
            raise UnicodeEncodeError(encoding, val, start, end, reason)
 
2876
    elif err.error_verb == 'ReadOnlyError':
 
2877
        raise errors.TransportNotPossible('readonly transport')
 
2878
    raise errors.UnknownErrorFromSmartServer(err)