~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: Launchpad Translations on behalf of bzr-core
  • Date: 2012-05-29 04:30:47 UTC
  • mto: (6581.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 6582.
  • Revision ID: launchpad_translations_on_behalf_of_bzr-core-20120529043047-mmj2hkq63ke8kl81
Launchpad automatic translations update.

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2006-2012 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
from __future__ import absolute_import
 
18
 
 
19
import bz2
 
20
import zlib
 
21
 
 
22
from bzrlib import (
 
23
    bencode,
 
24
    branch,
 
25
    bzrdir as _mod_bzrdir,
 
26
    config as _mod_config,
 
27
    controldir,
 
28
    debug,
 
29
    errors,
 
30
    gpg,
 
31
    graph,
 
32
    inventory_delta,
 
33
    lock,
 
34
    lockdir,
 
35
    osutils,
 
36
    registry,
 
37
    repository as _mod_repository,
 
38
    revision as _mod_revision,
 
39
    static_tuple,
 
40
    symbol_versioning,
 
41
    testament as _mod_testament,
 
42
    urlutils,
 
43
    vf_repository,
 
44
    vf_search,
 
45
    )
 
46
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
 
47
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
 
48
from bzrlib.errors import (
 
49
    NoSuchRevision,
 
50
    SmartProtocolError,
 
51
    )
 
52
from bzrlib.i18n import gettext
 
53
from bzrlib.inventory import Inventory
 
54
from bzrlib.lockable_files import LockableFiles
 
55
from bzrlib.smart import client, vfs, repository as smart_repo
 
56
from bzrlib.smart.client import _SmartClient
 
57
from bzrlib.revision import NULL_REVISION
 
58
from bzrlib.revisiontree import InventoryRevisionTree
 
59
from bzrlib.repository import RepositoryWriteLockResult, _LazyListJoin
 
60
from bzrlib.serializer import format_registry as serializer_format_registry
 
61
from bzrlib.trace import mutter, note, warning, log_exception_quietly
 
62
from bzrlib.versionedfile import FulltextContentFactory
 
63
 
 
64
 
 
65
_DEFAULT_SEARCH_DEPTH = 100
 
66
 
 
67
 
 
68
class _RpcHelper(object):
 
69
    """Mixin class that helps with issuing RPCs."""
 
70
 
 
71
    def _call(self, method, *args, **err_context):
 
72
        try:
 
73
            return self._client.call(method, *args)
 
74
        except errors.ErrorFromSmartServer, err:
 
75
            self._translate_error(err, **err_context)
 
76
 
 
77
    def _call_expecting_body(self, method, *args, **err_context):
 
78
        try:
 
79
            return self._client.call_expecting_body(method, *args)
 
80
        except errors.ErrorFromSmartServer, err:
 
81
            self._translate_error(err, **err_context)
 
82
 
 
83
    def _call_with_body_bytes(self, method, args, body_bytes, **err_context):
 
84
        try:
 
85
            return self._client.call_with_body_bytes(method, args, body_bytes)
 
86
        except errors.ErrorFromSmartServer, err:
 
87
            self._translate_error(err, **err_context)
 
88
 
 
89
    def _call_with_body_bytes_expecting_body(self, method, args, body_bytes,
 
90
                                             **err_context):
 
91
        try:
 
92
            return self._client.call_with_body_bytes_expecting_body(
 
93
                method, args, body_bytes)
 
94
        except errors.ErrorFromSmartServer, err:
 
95
            self._translate_error(err, **err_context)
 
96
 
 
97
 
 
98
def response_tuple_to_repo_format(response):
 
99
    """Convert a response tuple describing a repository format to a format."""
 
100
    format = RemoteRepositoryFormat()
 
101
    format._rich_root_data = (response[0] == 'yes')
 
102
    format._supports_tree_reference = (response[1] == 'yes')
 
103
    format._supports_external_lookups = (response[2] == 'yes')
 
104
    format._network_name = response[3]
 
105
    return format
 
106
 
 
107
 
 
108
# Note that RemoteBzrDirProber lives in bzrlib.bzrdir so bzrlib.remote
 
109
# does not have to be imported unless a remote format is involved.
 
110
 
 
111
class RemoteBzrDirFormat(_mod_bzrdir.BzrDirMetaFormat1):
 
112
    """Format representing bzrdirs accessed via a smart server"""
 
113
 
 
114
    supports_workingtrees = False
 
115
 
 
116
    colocated_branches = False
 
117
 
 
118
    def __init__(self):
 
119
        _mod_bzrdir.BzrDirMetaFormat1.__init__(self)
 
120
        # XXX: It's a bit ugly that the network name is here, because we'd
 
121
        # like to believe that format objects are stateless or at least
 
122
        # immutable,  However, we do at least avoid mutating the name after
 
123
        # it's returned.  See <https://bugs.launchpad.net/bzr/+bug/504102>
 
124
        self._network_name = None
 
125
 
 
126
    def __repr__(self):
 
127
        return "%s(_network_name=%r)" % (self.__class__.__name__,
 
128
            self._network_name)
 
129
 
 
130
    def get_format_description(self):
 
131
        if self._network_name:
 
132
            try:
 
133
                real_format = controldir.network_format_registry.get(
 
134
                        self._network_name)
 
135
            except KeyError:
 
136
                pass
 
137
            else:
 
138
                return 'Remote: ' + real_format.get_format_description()
 
139
        return 'bzr remote bzrdir'
 
140
 
 
141
    def get_format_string(self):
 
142
        raise NotImplementedError(self.get_format_string)
 
143
 
 
144
    def network_name(self):
 
145
        if self._network_name:
 
146
            return self._network_name
 
147
        else:
 
148
            raise AssertionError("No network name set.")
 
149
 
 
150
    def initialize_on_transport(self, transport):
 
151
        try:
 
152
            # hand off the request to the smart server
 
153
            client_medium = transport.get_smart_medium()
 
154
        except errors.NoSmartMedium:
 
155
            # TODO: lookup the local format from a server hint.
 
156
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
157
            return local_dir_format.initialize_on_transport(transport)
 
158
        client = _SmartClient(client_medium)
 
159
        path = client.remote_path_from_transport(transport)
 
160
        try:
 
161
            response = client.call('BzrDirFormat.initialize', path)
 
162
        except errors.ErrorFromSmartServer, err:
 
163
            _translate_error(err, path=path)
 
164
        if response[0] != 'ok':
 
165
            raise errors.SmartProtocolError('unexpected response code %s' % (response,))
 
166
        format = RemoteBzrDirFormat()
 
167
        self._supply_sub_formats_to(format)
 
168
        return RemoteBzrDir(transport, format)
 
169
 
 
170
    def parse_NoneTrueFalse(self, arg):
 
171
        if not arg:
 
172
            return None
 
173
        if arg == 'False':
 
174
            return False
 
175
        if arg == 'True':
 
176
            return True
 
177
        raise AssertionError("invalid arg %r" % arg)
 
178
 
 
179
    def _serialize_NoneTrueFalse(self, arg):
 
180
        if arg is False:
 
181
            return 'False'
 
182
        if arg:
 
183
            return 'True'
 
184
        return ''
 
185
 
 
186
    def _serialize_NoneString(self, arg):
 
187
        return arg or ''
 
188
 
 
189
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
 
190
        create_prefix=False, force_new_repo=False, stacked_on=None,
 
191
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
 
192
        shared_repo=False):
 
193
        try:
 
194
            # hand off the request to the smart server
 
195
            client_medium = transport.get_smart_medium()
 
196
        except errors.NoSmartMedium:
 
197
            do_vfs = True
 
198
        else:
 
199
            # Decline to open it if the server doesn't support our required
 
200
            # version (3) so that the VFS-based transport will do it.
 
201
            if client_medium.should_probe():
 
202
                try:
 
203
                    server_version = client_medium.protocol_version()
 
204
                    if server_version != '2':
 
205
                        do_vfs = True
 
206
                    else:
 
207
                        do_vfs = False
 
208
                except errors.SmartProtocolError:
 
209
                    # Apparently there's no usable smart server there, even though
 
210
                    # the medium supports the smart protocol.
 
211
                    do_vfs = True
 
212
            else:
 
213
                do_vfs = False
 
214
        if not do_vfs:
 
215
            client = _SmartClient(client_medium)
 
216
            path = client.remote_path_from_transport(transport)
 
217
            if client_medium._is_remote_before((1, 16)):
 
218
                do_vfs = True
 
219
        if do_vfs:
 
220
            # TODO: lookup the local format from a server hint.
 
221
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
222
            self._supply_sub_formats_to(local_dir_format)
 
223
            return local_dir_format.initialize_on_transport_ex(transport,
 
224
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
225
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
226
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
227
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
228
                vfs_only=True)
 
229
        return self._initialize_on_transport_ex_rpc(client, path, transport,
 
230
            use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
231
            stack_on_pwd, repo_format_name, make_working_trees, shared_repo)
 
232
 
 
233
    def _initialize_on_transport_ex_rpc(self, client, path, transport,
 
234
        use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
235
        stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
 
236
        args = []
 
237
        args.append(self._serialize_NoneTrueFalse(use_existing_dir))
 
238
        args.append(self._serialize_NoneTrueFalse(create_prefix))
 
239
        args.append(self._serialize_NoneTrueFalse(force_new_repo))
 
240
        args.append(self._serialize_NoneString(stacked_on))
 
241
        # stack_on_pwd is often/usually our transport
 
242
        if stack_on_pwd:
 
243
            try:
 
244
                stack_on_pwd = transport.relpath(stack_on_pwd)
 
245
                if not stack_on_pwd:
 
246
                    stack_on_pwd = '.'
 
247
            except errors.PathNotChild:
 
248
                pass
 
249
        args.append(self._serialize_NoneString(stack_on_pwd))
 
250
        args.append(self._serialize_NoneString(repo_format_name))
 
251
        args.append(self._serialize_NoneTrueFalse(make_working_trees))
 
252
        args.append(self._serialize_NoneTrueFalse(shared_repo))
 
253
        request_network_name = self._network_name or \
 
254
            _mod_bzrdir.BzrDirFormat.get_default_format().network_name()
 
255
        try:
 
256
            response = client.call('BzrDirFormat.initialize_ex_1.16',
 
257
                request_network_name, path, *args)
 
258
        except errors.UnknownSmartMethod:
 
259
            client._medium._remember_remote_is_before((1,16))
 
260
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
261
            self._supply_sub_formats_to(local_dir_format)
 
262
            return local_dir_format.initialize_on_transport_ex(transport,
 
263
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
264
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
265
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
266
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
267
                vfs_only=True)
 
268
        except errors.ErrorFromSmartServer, err:
 
269
            _translate_error(err, path=path)
 
270
        repo_path = response[0]
 
271
        bzrdir_name = response[6]
 
272
        require_stacking = response[7]
 
273
        require_stacking = self.parse_NoneTrueFalse(require_stacking)
 
274
        format = RemoteBzrDirFormat()
 
275
        format._network_name = bzrdir_name
 
276
        self._supply_sub_formats_to(format)
 
277
        bzrdir = RemoteBzrDir(transport, format, _client=client)
 
278
        if repo_path:
 
279
            repo_format = response_tuple_to_repo_format(response[1:])
 
280
            if repo_path == '.':
 
281
                repo_path = ''
 
282
            if repo_path:
 
283
                repo_bzrdir_format = RemoteBzrDirFormat()
 
284
                repo_bzrdir_format._network_name = response[5]
 
285
                repo_bzr = RemoteBzrDir(transport.clone(repo_path),
 
286
                    repo_bzrdir_format)
 
287
            else:
 
288
                repo_bzr = bzrdir
 
289
            final_stack = response[8] or None
 
290
            final_stack_pwd = response[9] or None
 
291
            if final_stack_pwd:
 
292
                final_stack_pwd = urlutils.join(
 
293
                    transport.base, final_stack_pwd)
 
294
            remote_repo = RemoteRepository(repo_bzr, repo_format)
 
295
            if len(response) > 10:
 
296
                # Updated server verb that locks remotely.
 
297
                repo_lock_token = response[10] or None
 
298
                remote_repo.lock_write(repo_lock_token, _skip_rpc=True)
 
299
                if repo_lock_token:
 
300
                    remote_repo.dont_leave_lock_in_place()
 
301
            else:
 
302
                remote_repo.lock_write()
 
303
            policy = _mod_bzrdir.UseExistingRepository(remote_repo, final_stack,
 
304
                final_stack_pwd, require_stacking)
 
305
            policy.acquire_repository()
 
306
        else:
 
307
            remote_repo = None
 
308
            policy = None
 
309
        bzrdir._format.set_branch_format(self.get_branch_format())
 
310
        if require_stacking:
 
311
            # The repo has already been created, but we need to make sure that
 
312
            # we'll make a stackable branch.
 
313
            bzrdir._format.require_stacking(_skip_repo=True)
 
314
        return remote_repo, bzrdir, require_stacking, policy
 
315
 
 
316
    def _open(self, transport):
 
317
        return RemoteBzrDir(transport, self)
 
318
 
 
319
    def __eq__(self, other):
 
320
        if not isinstance(other, RemoteBzrDirFormat):
 
321
            return False
 
322
        return self.get_format_description() == other.get_format_description()
 
323
 
 
324
    def __return_repository_format(self):
 
325
        # Always return a RemoteRepositoryFormat object, but if a specific bzr
 
326
        # repository format has been asked for, tell the RemoteRepositoryFormat
 
327
        # that it should use that for init() etc.
 
328
        result = RemoteRepositoryFormat()
 
329
        custom_format = getattr(self, '_repository_format', None)
 
330
        if custom_format:
 
331
            if isinstance(custom_format, RemoteRepositoryFormat):
 
332
                return custom_format
 
333
            else:
 
334
                # We will use the custom format to create repositories over the
 
335
                # wire; expose its details like rich_root_data for code to
 
336
                # query
 
337
                result._custom_format = custom_format
 
338
        return result
 
339
 
 
340
    def get_branch_format(self):
 
341
        result = _mod_bzrdir.BzrDirMetaFormat1.get_branch_format(self)
 
342
        if not isinstance(result, RemoteBranchFormat):
 
343
            new_result = RemoteBranchFormat()
 
344
            new_result._custom_format = result
 
345
            # cache the result
 
346
            self.set_branch_format(new_result)
 
347
            result = new_result
 
348
        return result
 
349
 
 
350
    repository_format = property(__return_repository_format,
 
351
        _mod_bzrdir.BzrDirMetaFormat1._set_repository_format) #.im_func)
 
352
 
 
353
 
 
354
class RemoteControlStore(_mod_config.IniFileStore):
 
355
    """Control store which attempts to use HPSS calls to retrieve control store.
 
356
 
 
357
    Note that this is specific to bzr-based formats.
 
358
    """
 
359
 
 
360
    def __init__(self, bzrdir):
 
361
        super(RemoteControlStore, self).__init__()
 
362
        self.bzrdir = bzrdir
 
363
        self._real_store = None
 
364
 
 
365
    def lock_write(self, token=None):
 
366
        self._ensure_real()
 
367
        return self._real_store.lock_write(token)
 
368
 
 
369
    def unlock(self):
 
370
        self._ensure_real()
 
371
        return self._real_store.unlock()
 
372
 
 
373
    @needs_write_lock
 
374
    def save(self):
 
375
        # We need to be able to override the undecorated implementation
 
376
        self.save_without_locking()
 
377
 
 
378
    def save_without_locking(self):
 
379
        super(RemoteControlStore, self).save()
 
380
 
 
381
    def _ensure_real(self):
 
382
        self.bzrdir._ensure_real()
 
383
        if self._real_store is None:
 
384
            self._real_store = _mod_config.ControlStore(self.bzrdir)
 
385
 
 
386
    def external_url(self):
 
387
        return self.bzrdir.user_url
 
388
 
 
389
    def _load_content(self):
 
390
        medium = self.bzrdir._client._medium
 
391
        path = self.bzrdir._path_for_remote_call(self.bzrdir._client)
 
392
        try:
 
393
            response, handler = self.bzrdir._call_expecting_body(
 
394
                'BzrDir.get_config_file', path)
 
395
        except errors.UnknownSmartMethod:
 
396
            self._ensure_real()
 
397
            return self._real_store._load_content()
 
398
        if len(response) and response[0] != 'ok':
 
399
            raise errors.UnexpectedSmartServerResponse(response)
 
400
        return handler.read_body_bytes()
 
401
 
 
402
    def _save_content(self, content):
 
403
        # FIXME JRV 2011-11-22: Ideally this should use a
 
404
        # HPSS call too, but at the moment it is not possible
 
405
        # to write lock control directories.
 
406
        self._ensure_real()
 
407
        return self._real_store._save_content(content)
 
408
 
 
409
 
 
410
class RemoteBzrDir(_mod_bzrdir.BzrDir, _RpcHelper):
 
411
    """Control directory on a remote server, accessed via bzr:// or similar."""
 
412
 
 
413
    def __init__(self, transport, format, _client=None, _force_probe=False):
 
414
        """Construct a RemoteBzrDir.
 
415
 
 
416
        :param _client: Private parameter for testing. Disables probing and the
 
417
            use of a real bzrdir.
 
418
        """
 
419
        _mod_bzrdir.BzrDir.__init__(self, transport, format)
 
420
        # this object holds a delegated bzrdir that uses file-level operations
 
421
        # to talk to the other side
 
422
        self._real_bzrdir = None
 
423
        self._has_working_tree = None
 
424
        # 1-shot cache for the call pattern 'create_branch; open_branch' - see
 
425
        # create_branch for details.
 
426
        self._next_open_branch_result = None
 
427
 
 
428
        if _client is None:
 
429
            medium = transport.get_smart_medium()
 
430
            self._client = client._SmartClient(medium)
 
431
        else:
 
432
            self._client = _client
 
433
            if not _force_probe:
 
434
                return
 
435
 
 
436
        self._probe_bzrdir()
 
437
 
 
438
    def __repr__(self):
 
439
        return '%s(%r)' % (self.__class__.__name__, self._client)
 
440
 
 
441
    def _probe_bzrdir(self):
 
442
        medium = self._client._medium
 
443
        path = self._path_for_remote_call(self._client)
 
444
        if medium._is_remote_before((2, 1)):
 
445
            self._rpc_open(path)
 
446
            return
 
447
        try:
 
448
            self._rpc_open_2_1(path)
 
449
            return
 
450
        except errors.UnknownSmartMethod:
 
451
            medium._remember_remote_is_before((2, 1))
 
452
            self._rpc_open(path)
 
453
 
 
454
    def _rpc_open_2_1(self, path):
 
455
        response = self._call('BzrDir.open_2.1', path)
 
456
        if response == ('no',):
 
457
            raise errors.NotBranchError(path=self.root_transport.base)
 
458
        elif response[0] == 'yes':
 
459
            if response[1] == 'yes':
 
460
                self._has_working_tree = True
 
461
            elif response[1] == 'no':
 
462
                self._has_working_tree = False
 
463
            else:
 
464
                raise errors.UnexpectedSmartServerResponse(response)
 
465
        else:
 
466
            raise errors.UnexpectedSmartServerResponse(response)
 
467
 
 
468
    def _rpc_open(self, path):
 
469
        response = self._call('BzrDir.open', path)
 
470
        if response not in [('yes',), ('no',)]:
 
471
            raise errors.UnexpectedSmartServerResponse(response)
 
472
        if response == ('no',):
 
473
            raise errors.NotBranchError(path=self.root_transport.base)
 
474
 
 
475
    def _ensure_real(self):
 
476
        """Ensure that there is a _real_bzrdir set.
 
477
 
 
478
        Used before calls to self._real_bzrdir.
 
479
        """
 
480
        if not self._real_bzrdir:
 
481
            if 'hpssvfs' in debug.debug_flags:
 
482
                import traceback
 
483
                warning('VFS BzrDir access triggered\n%s',
 
484
                    ''.join(traceback.format_stack()))
 
485
            self._real_bzrdir = _mod_bzrdir.BzrDir.open_from_transport(
 
486
                self.root_transport, probers=[_mod_bzrdir.BzrProber])
 
487
            self._format._network_name = \
 
488
                self._real_bzrdir._format.network_name()
 
489
 
 
490
    def _translate_error(self, err, **context):
 
491
        _translate_error(err, bzrdir=self, **context)
 
492
 
 
493
    def break_lock(self):
 
494
        # Prevent aliasing problems in the next_open_branch_result cache.
 
495
        # See create_branch for rationale.
 
496
        self._next_open_branch_result = None
 
497
        return _mod_bzrdir.BzrDir.break_lock(self)
 
498
 
 
499
    def _vfs_checkout_metadir(self):
 
500
        self._ensure_real()
 
501
        return self._real_bzrdir.checkout_metadir()
 
502
 
 
503
    def checkout_metadir(self):
 
504
        """Retrieve the controldir format to use for checkouts of this one.
 
505
        """
 
506
        medium = self._client._medium
 
507
        if medium._is_remote_before((2, 5)):
 
508
            return self._vfs_checkout_metadir()
 
509
        path = self._path_for_remote_call(self._client)
 
510
        try:
 
511
            response = self._client.call('BzrDir.checkout_metadir',
 
512
                path)
 
513
        except errors.UnknownSmartMethod:
 
514
            medium._remember_remote_is_before((2, 5))
 
515
            return self._vfs_checkout_metadir()
 
516
        if len(response) != 3:
 
517
            raise errors.UnexpectedSmartServerResponse(response)
 
518
        control_name, repo_name, branch_name = response
 
519
        try:
 
520
            format = controldir.network_format_registry.get(control_name)
 
521
        except KeyError:
 
522
            raise errors.UnknownFormatError(kind='control',
 
523
                format=control_name)
 
524
        if repo_name:
 
525
            try:
 
526
                repo_format = _mod_repository.network_format_registry.get(
 
527
                    repo_name)
 
528
            except KeyError:
 
529
                raise errors.UnknownFormatError(kind='repository',
 
530
                    format=repo_name)
 
531
            format.repository_format = repo_format
 
532
        if branch_name:
 
533
            try:
 
534
                format.set_branch_format(
 
535
                    branch.network_format_registry.get(branch_name))
 
536
            except KeyError:
 
537
                raise errors.UnknownFormatError(kind='branch',
 
538
                    format=branch_name)
 
539
        return format
 
540
 
 
541
    def _vfs_cloning_metadir(self, require_stacking=False):
 
542
        self._ensure_real()
 
543
        return self._real_bzrdir.cloning_metadir(
 
544
            require_stacking=require_stacking)
 
545
 
 
546
    def cloning_metadir(self, require_stacking=False):
 
547
        medium = self._client._medium
 
548
        if medium._is_remote_before((1, 13)):
 
549
            return self._vfs_cloning_metadir(require_stacking=require_stacking)
 
550
        verb = 'BzrDir.cloning_metadir'
 
551
        if require_stacking:
 
552
            stacking = 'True'
 
553
        else:
 
554
            stacking = 'False'
 
555
        path = self._path_for_remote_call(self._client)
 
556
        try:
 
557
            response = self._call(verb, path, stacking)
 
558
        except errors.UnknownSmartMethod:
 
559
            medium._remember_remote_is_before((1, 13))
 
560
            return self._vfs_cloning_metadir(require_stacking=require_stacking)
 
561
        except errors.UnknownErrorFromSmartServer, err:
 
562
            if err.error_tuple != ('BranchReference',):
 
563
                raise
 
564
            # We need to resolve the branch reference to determine the
 
565
            # cloning_metadir.  This causes unnecessary RPCs to open the
 
566
            # referenced branch (and bzrdir, etc) but only when the caller
 
567
            # didn't already resolve the branch reference.
 
568
            referenced_branch = self.open_branch()
 
569
            return referenced_branch.bzrdir.cloning_metadir()
 
570
        if len(response) != 3:
 
571
            raise errors.UnexpectedSmartServerResponse(response)
 
572
        control_name, repo_name, branch_info = response
 
573
        if len(branch_info) != 2:
 
574
            raise errors.UnexpectedSmartServerResponse(response)
 
575
        branch_ref, branch_name = branch_info
 
576
        try:
 
577
            format = controldir.network_format_registry.get(control_name)
 
578
        except KeyError:
 
579
            raise errors.UnknownFormatError(kind='control', format=control_name)
 
580
 
 
581
        if repo_name:
 
582
            try:
 
583
                format.repository_format = _mod_repository.network_format_registry.get(
 
584
                    repo_name)
 
585
            except KeyError:
 
586
                raise errors.UnknownFormatError(kind='repository',
 
587
                    format=repo_name)
 
588
        if branch_ref == 'ref':
 
589
            # XXX: we need possible_transports here to avoid reopening the
 
590
            # connection to the referenced location
 
591
            ref_bzrdir = _mod_bzrdir.BzrDir.open(branch_name)
 
592
            branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
 
593
            format.set_branch_format(branch_format)
 
594
        elif branch_ref == 'branch':
 
595
            if branch_name:
 
596
                try:
 
597
                    branch_format = branch.network_format_registry.get(
 
598
                        branch_name)
 
599
                except KeyError:
 
600
                    raise errors.UnknownFormatError(kind='branch',
 
601
                        format=branch_name)
 
602
                format.set_branch_format(branch_format)
 
603
        else:
 
604
            raise errors.UnexpectedSmartServerResponse(response)
 
605
        return format
 
606
 
 
607
    def create_repository(self, shared=False):
 
608
        # as per meta1 formats - just delegate to the format object which may
 
609
        # be parameterised.
 
610
        result = self._format.repository_format.initialize(self, shared)
 
611
        if not isinstance(result, RemoteRepository):
 
612
            return self.open_repository()
 
613
        else:
 
614
            return result
 
615
 
 
616
    def destroy_repository(self):
 
617
        """See BzrDir.destroy_repository"""
 
618
        path = self._path_for_remote_call(self._client)
 
619
        try:
 
620
            response = self._call('BzrDir.destroy_repository', path)
 
621
        except errors.UnknownSmartMethod:
 
622
            self._ensure_real()
 
623
            self._real_bzrdir.destroy_repository()
 
624
            return
 
625
        if response[0] != 'ok':
 
626
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
627
 
 
628
    def create_branch(self, name=None, repository=None,
 
629
                      append_revisions_only=None):
 
630
        if name is None:
 
631
            name = self._get_selected_branch()
 
632
        if name != "":
 
633
            raise errors.NoColocatedBranchSupport(self)
 
634
        # as per meta1 formats - just delegate to the format object which may
 
635
        # be parameterised.
 
636
        real_branch = self._format.get_branch_format().initialize(self,
 
637
            name=name, repository=repository,
 
638
            append_revisions_only=append_revisions_only)
 
639
        if not isinstance(real_branch, RemoteBranch):
 
640
            if not isinstance(repository, RemoteRepository):
 
641
                raise AssertionError(
 
642
                    'need a RemoteRepository to use with RemoteBranch, got %r'
 
643
                    % (repository,))
 
644
            result = RemoteBranch(self, repository, real_branch, name=name)
 
645
        else:
 
646
            result = real_branch
 
647
        # BzrDir.clone_on_transport() uses the result of create_branch but does
 
648
        # not return it to its callers; we save approximately 8% of our round
 
649
        # trips by handing the branch we created back to the first caller to
 
650
        # open_branch rather than probing anew. Long term we need a API in
 
651
        # bzrdir that doesn't discard result objects (like result_branch).
 
652
        # RBC 20090225
 
653
        self._next_open_branch_result = result
 
654
        return result
 
655
 
 
656
    def destroy_branch(self, name=None):
 
657
        """See BzrDir.destroy_branch"""
 
658
        if name is None:
 
659
            name = self._get_selected_branch()
 
660
        if name != "":
 
661
            raise errors.NoColocatedBranchSupport(self)
 
662
        path = self._path_for_remote_call(self._client)
 
663
        try:
 
664
            if name != "":
 
665
                args = (name, )
 
666
            else:
 
667
                args = ()
 
668
            response = self._call('BzrDir.destroy_branch', path, *args)
 
669
        except errors.UnknownSmartMethod:
 
670
            self._ensure_real()
 
671
            self._real_bzrdir.destroy_branch(name=name)
 
672
            self._next_open_branch_result = None
 
673
            return
 
674
        self._next_open_branch_result = None
 
675
        if response[0] != 'ok':
 
676
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
677
 
 
678
    def create_workingtree(self, revision_id=None, from_branch=None,
 
679
        accelerator_tree=None, hardlink=False):
 
680
        raise errors.NotLocalUrl(self.transport.base)
 
681
 
 
682
    def find_branch_format(self, name=None):
 
683
        """Find the branch 'format' for this bzrdir.
 
684
 
 
685
        This might be a synthetic object for e.g. RemoteBranch and SVN.
 
686
        """
 
687
        b = self.open_branch(name=name)
 
688
        return b._format
 
689
 
 
690
    def get_branches(self, possible_transports=None, ignore_fallbacks=False):
 
691
        path = self._path_for_remote_call(self._client)
 
692
        try:
 
693
            response, handler = self._call_expecting_body(
 
694
                'BzrDir.get_branches', path)
 
695
        except errors.UnknownSmartMethod:
 
696
            self._ensure_real()
 
697
            return self._real_bzrdir.get_branches()
 
698
        if response[0] != "success":
 
699
            raise errors.UnexpectedSmartServerResponse(response)
 
700
        body = bencode.bdecode(handler.read_body_bytes())
 
701
        ret = {}
 
702
        for (name, value) in body.iteritems():
 
703
            ret[name] = self._open_branch(name, value[0], value[1],
 
704
                possible_transports=possible_transports,
 
705
                ignore_fallbacks=ignore_fallbacks)
 
706
        return ret
 
707
 
 
708
    def set_branch_reference(self, target_branch, name=None):
 
709
        """See BzrDir.set_branch_reference()."""
 
710
        if name is None:
 
711
            name = self._get_selected_branch()
 
712
        if name != "":
 
713
            raise errors.NoColocatedBranchSupport(self)
 
714
        self._ensure_real()
 
715
        return self._real_bzrdir.set_branch_reference(target_branch, name=name)
 
716
 
 
717
    def get_branch_reference(self, name=None):
 
718
        """See BzrDir.get_branch_reference()."""
 
719
        if name is None:
 
720
            name = self._get_selected_branch()
 
721
        if name != "":
 
722
            raise errors.NoColocatedBranchSupport(self)
 
723
        response = self._get_branch_reference()
 
724
        if response[0] == 'ref':
 
725
            return response[1]
 
726
        else:
 
727
            return None
 
728
 
 
729
    def _get_branch_reference(self):
 
730
        path = self._path_for_remote_call(self._client)
 
731
        medium = self._client._medium
 
732
        candidate_calls = [
 
733
            ('BzrDir.open_branchV3', (2, 1)),
 
734
            ('BzrDir.open_branchV2', (1, 13)),
 
735
            ('BzrDir.open_branch', None),
 
736
            ]
 
737
        for verb, required_version in candidate_calls:
 
738
            if required_version and medium._is_remote_before(required_version):
 
739
                continue
 
740
            try:
 
741
                response = self._call(verb, path)
 
742
            except errors.UnknownSmartMethod:
 
743
                if required_version is None:
 
744
                    raise
 
745
                medium._remember_remote_is_before(required_version)
 
746
            else:
 
747
                break
 
748
        if verb == 'BzrDir.open_branch':
 
749
            if response[0] != 'ok':
 
750
                raise errors.UnexpectedSmartServerResponse(response)
 
751
            if response[1] != '':
 
752
                return ('ref', response[1])
 
753
            else:
 
754
                return ('branch', '')
 
755
        if response[0] not in ('ref', 'branch'):
 
756
            raise errors.UnexpectedSmartServerResponse(response)
 
757
        return response
 
758
 
 
759
    def _get_tree_branch(self, name=None):
 
760
        """See BzrDir._get_tree_branch()."""
 
761
        return None, self.open_branch(name=name)
 
762
 
 
763
    def _open_branch(self, name, kind, location_or_format,
 
764
                     ignore_fallbacks=False, possible_transports=None):
 
765
        if kind == 'ref':
 
766
            # a branch reference, use the existing BranchReference logic.
 
767
            format = BranchReferenceFormat()
 
768
            return format.open(self, name=name, _found=True,
 
769
                location=location_or_format, ignore_fallbacks=ignore_fallbacks,
 
770
                possible_transports=possible_transports)
 
771
        branch_format_name = location_or_format
 
772
        if not branch_format_name:
 
773
            branch_format_name = None
 
774
        format = RemoteBranchFormat(network_name=branch_format_name)
 
775
        return RemoteBranch(self, self.find_repository(), format=format,
 
776
            setup_stacking=not ignore_fallbacks, name=name,
 
777
            possible_transports=possible_transports)
 
778
 
 
779
    def open_branch(self, name=None, unsupported=False,
 
780
                    ignore_fallbacks=False, possible_transports=None):
 
781
        if name is None:
 
782
            name = self._get_selected_branch()
 
783
        if name != "":
 
784
            raise errors.NoColocatedBranchSupport(self)
 
785
        if unsupported:
 
786
            raise NotImplementedError('unsupported flag support not implemented yet.')
 
787
        if self._next_open_branch_result is not None:
 
788
            # See create_branch for details.
 
789
            result = self._next_open_branch_result
 
790
            self._next_open_branch_result = None
 
791
            return result
 
792
        response = self._get_branch_reference()
 
793
        return self._open_branch(name, response[0], response[1],
 
794
            possible_transports=possible_transports,
 
795
            ignore_fallbacks=ignore_fallbacks)
 
796
 
 
797
    def _open_repo_v1(self, path):
 
798
        verb = 'BzrDir.find_repository'
 
799
        response = self._call(verb, path)
 
800
        if response[0] != 'ok':
 
801
            raise errors.UnexpectedSmartServerResponse(response)
 
802
        # servers that only support the v1 method don't support external
 
803
        # references either.
 
804
        self._ensure_real()
 
805
        repo = self._real_bzrdir.open_repository()
 
806
        response = response + ('no', repo._format.network_name())
 
807
        return response, repo
 
808
 
 
809
    def _open_repo_v2(self, path):
 
810
        verb = 'BzrDir.find_repositoryV2'
 
811
        response = self._call(verb, path)
 
812
        if response[0] != 'ok':
 
813
            raise errors.UnexpectedSmartServerResponse(response)
 
814
        self._ensure_real()
 
815
        repo = self._real_bzrdir.open_repository()
 
816
        response = response + (repo._format.network_name(),)
 
817
        return response, repo
 
818
 
 
819
    def _open_repo_v3(self, path):
 
820
        verb = 'BzrDir.find_repositoryV3'
 
821
        medium = self._client._medium
 
822
        if medium._is_remote_before((1, 13)):
 
823
            raise errors.UnknownSmartMethod(verb)
 
824
        try:
 
825
            response = self._call(verb, path)
 
826
        except errors.UnknownSmartMethod:
 
827
            medium._remember_remote_is_before((1, 13))
 
828
            raise
 
829
        if response[0] != 'ok':
 
830
            raise errors.UnexpectedSmartServerResponse(response)
 
831
        return response, None
 
832
 
 
833
    def open_repository(self):
 
834
        path = self._path_for_remote_call(self._client)
 
835
        response = None
 
836
        for probe in [self._open_repo_v3, self._open_repo_v2,
 
837
            self._open_repo_v1]:
 
838
            try:
 
839
                response, real_repo = probe(path)
 
840
                break
 
841
            except errors.UnknownSmartMethod:
 
842
                pass
 
843
        if response is None:
 
844
            raise errors.UnknownSmartMethod('BzrDir.find_repository{3,2,}')
 
845
        if response[0] != 'ok':
 
846
            raise errors.UnexpectedSmartServerResponse(response)
 
847
        if len(response) != 6:
 
848
            raise SmartProtocolError('incorrect response length %s' % (response,))
 
849
        if response[1] == '':
 
850
            # repo is at this dir.
 
851
            format = response_tuple_to_repo_format(response[2:])
 
852
            # Used to support creating a real format instance when needed.
 
853
            format._creating_bzrdir = self
 
854
            remote_repo = RemoteRepository(self, format)
 
855
            format._creating_repo = remote_repo
 
856
            if real_repo is not None:
 
857
                remote_repo._set_real_repository(real_repo)
 
858
            return remote_repo
 
859
        else:
 
860
            raise errors.NoRepositoryPresent(self)
 
861
 
 
862
    def has_workingtree(self):
 
863
        if self._has_working_tree is None:
 
864
            path = self._path_for_remote_call(self._client)
 
865
            try:
 
866
                response = self._call('BzrDir.has_workingtree', path)
 
867
            except errors.UnknownSmartMethod:
 
868
                self._ensure_real()
 
869
                self._has_working_tree = self._real_bzrdir.has_workingtree()
 
870
            else:
 
871
                if response[0] not in ('yes', 'no'):
 
872
                    raise SmartProtocolError('unexpected response code %s' % (response,))
 
873
                self._has_working_tree = (response[0] == 'yes')
 
874
        return self._has_working_tree
 
875
 
 
876
    def open_workingtree(self, recommend_upgrade=True):
 
877
        if self.has_workingtree():
 
878
            raise errors.NotLocalUrl(self.root_transport)
 
879
        else:
 
880
            raise errors.NoWorkingTree(self.root_transport.base)
 
881
 
 
882
    def _path_for_remote_call(self, client):
 
883
        """Return the path to be used for this bzrdir in a remote call."""
 
884
        return urlutils.split_segment_parameters_raw(
 
885
            client.remote_path_from_transport(self.root_transport))[0]
 
886
 
 
887
    def get_branch_transport(self, branch_format, name=None):
 
888
        self._ensure_real()
 
889
        return self._real_bzrdir.get_branch_transport(branch_format, name=name)
 
890
 
 
891
    def get_repository_transport(self, repository_format):
 
892
        self._ensure_real()
 
893
        return self._real_bzrdir.get_repository_transport(repository_format)
 
894
 
 
895
    def get_workingtree_transport(self, workingtree_format):
 
896
        self._ensure_real()
 
897
        return self._real_bzrdir.get_workingtree_transport(workingtree_format)
 
898
 
 
899
    def can_convert_format(self):
 
900
        """Upgrading of remote bzrdirs is not supported yet."""
 
901
        return False
 
902
 
 
903
    def needs_format_conversion(self, format):
 
904
        """Upgrading of remote bzrdirs is not supported yet."""
 
905
        return False
 
906
 
 
907
    def _get_config(self):
 
908
        return RemoteBzrDirConfig(self)
 
909
 
 
910
    def _get_config_store(self):
 
911
        return RemoteControlStore(self)
 
912
 
 
913
 
 
914
class RemoteRepositoryFormat(vf_repository.VersionedFileRepositoryFormat):
 
915
    """Format for repositories accessed over a _SmartClient.
 
916
 
 
917
    Instances of this repository are represented by RemoteRepository
 
918
    instances.
 
919
 
 
920
    The RemoteRepositoryFormat is parameterized during construction
 
921
    to reflect the capabilities of the real, remote format. Specifically
 
922
    the attributes rich_root_data and supports_tree_reference are set
 
923
    on a per instance basis, and are not set (and should not be) at
 
924
    the class level.
 
925
 
 
926
    :ivar _custom_format: If set, a specific concrete repository format that
 
927
        will be used when initializing a repository with this
 
928
        RemoteRepositoryFormat.
 
929
    :ivar _creating_repo: If set, the repository object that this
 
930
        RemoteRepositoryFormat was created for: it can be called into
 
931
        to obtain data like the network name.
 
932
    """
 
933
 
 
934
    _matchingbzrdir = RemoteBzrDirFormat()
 
935
    supports_full_versioned_files = True
 
936
    supports_leaving_lock = True
 
937
 
 
938
    def __init__(self):
 
939
        _mod_repository.RepositoryFormat.__init__(self)
 
940
        self._custom_format = None
 
941
        self._network_name = None
 
942
        self._creating_bzrdir = None
 
943
        self._revision_graph_can_have_wrong_parents = None
 
944
        self._supports_chks = None
 
945
        self._supports_external_lookups = None
 
946
        self._supports_tree_reference = None
 
947
        self._supports_funky_characters = None
 
948
        self._supports_nesting_repositories = None
 
949
        self._rich_root_data = None
 
950
 
 
951
    def __repr__(self):
 
952
        return "%s(_network_name=%r)" % (self.__class__.__name__,
 
953
            self._network_name)
 
954
 
 
955
    @property
 
956
    def fast_deltas(self):
 
957
        self._ensure_real()
 
958
        return self._custom_format.fast_deltas
 
959
 
 
960
    @property
 
961
    def rich_root_data(self):
 
962
        if self._rich_root_data is None:
 
963
            self._ensure_real()
 
964
            self._rich_root_data = self._custom_format.rich_root_data
 
965
        return self._rich_root_data
 
966
 
 
967
    @property
 
968
    def supports_chks(self):
 
969
        if self._supports_chks is None:
 
970
            self._ensure_real()
 
971
            self._supports_chks = self._custom_format.supports_chks
 
972
        return self._supports_chks
 
973
 
 
974
    @property
 
975
    def supports_external_lookups(self):
 
976
        if self._supports_external_lookups is None:
 
977
            self._ensure_real()
 
978
            self._supports_external_lookups = \
 
979
                self._custom_format.supports_external_lookups
 
980
        return self._supports_external_lookups
 
981
 
 
982
    @property
 
983
    def supports_funky_characters(self):
 
984
        if self._supports_funky_characters is None:
 
985
            self._ensure_real()
 
986
            self._supports_funky_characters = \
 
987
                self._custom_format.supports_funky_characters
 
988
        return self._supports_funky_characters
 
989
 
 
990
    @property
 
991
    def supports_nesting_repositories(self):
 
992
        if self._supports_nesting_repositories is None:
 
993
            self._ensure_real()
 
994
            self._supports_nesting_repositories = \
 
995
                self._custom_format.supports_nesting_repositories
 
996
        return self._supports_nesting_repositories
 
997
 
 
998
    @property
 
999
    def supports_tree_reference(self):
 
1000
        if self._supports_tree_reference is None:
 
1001
            self._ensure_real()
 
1002
            self._supports_tree_reference = \
 
1003
                self._custom_format.supports_tree_reference
 
1004
        return self._supports_tree_reference
 
1005
 
 
1006
    @property
 
1007
    def revision_graph_can_have_wrong_parents(self):
 
1008
        if self._revision_graph_can_have_wrong_parents is None:
 
1009
            self._ensure_real()
 
1010
            self._revision_graph_can_have_wrong_parents = \
 
1011
                self._custom_format.revision_graph_can_have_wrong_parents
 
1012
        return self._revision_graph_can_have_wrong_parents
 
1013
 
 
1014
    def _vfs_initialize(self, a_bzrdir, shared):
 
1015
        """Helper for common code in initialize."""
 
1016
        if self._custom_format:
 
1017
            # Custom format requested
 
1018
            result = self._custom_format.initialize(a_bzrdir, shared=shared)
 
1019
        elif self._creating_bzrdir is not None:
 
1020
            # Use the format that the repository we were created to back
 
1021
            # has.
 
1022
            prior_repo = self._creating_bzrdir.open_repository()
 
1023
            prior_repo._ensure_real()
 
1024
            result = prior_repo._real_repository._format.initialize(
 
1025
                a_bzrdir, shared=shared)
 
1026
        else:
 
1027
            # assume that a_bzr is a RemoteBzrDir but the smart server didn't
 
1028
            # support remote initialization.
 
1029
            # We delegate to a real object at this point (as RemoteBzrDir
 
1030
            # delegate to the repository format which would lead to infinite
 
1031
            # recursion if we just called a_bzrdir.create_repository.
 
1032
            a_bzrdir._ensure_real()
 
1033
            result = a_bzrdir._real_bzrdir.create_repository(shared=shared)
 
1034
        if not isinstance(result, RemoteRepository):
 
1035
            return self.open(a_bzrdir)
 
1036
        else:
 
1037
            return result
 
1038
 
 
1039
    def initialize(self, a_bzrdir, shared=False):
 
1040
        # Being asked to create on a non RemoteBzrDir:
 
1041
        if not isinstance(a_bzrdir, RemoteBzrDir):
 
1042
            return self._vfs_initialize(a_bzrdir, shared)
 
1043
        medium = a_bzrdir._client._medium
 
1044
        if medium._is_remote_before((1, 13)):
 
1045
            return self._vfs_initialize(a_bzrdir, shared)
 
1046
        # Creating on a remote bzr dir.
 
1047
        # 1) get the network name to use.
 
1048
        if self._custom_format:
 
1049
            network_name = self._custom_format.network_name()
 
1050
        elif self._network_name:
 
1051
            network_name = self._network_name
 
1052
        else:
 
1053
            # Select the current bzrlib default and ask for that.
 
1054
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
 
1055
            reference_format = reference_bzrdir_format.repository_format
 
1056
            network_name = reference_format.network_name()
 
1057
        # 2) try direct creation via RPC
 
1058
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
 
1059
        verb = 'BzrDir.create_repository'
 
1060
        if shared:
 
1061
            shared_str = 'True'
 
1062
        else:
 
1063
            shared_str = 'False'
 
1064
        try:
 
1065
            response = a_bzrdir._call(verb, path, network_name, shared_str)
 
1066
        except errors.UnknownSmartMethod:
 
1067
            # Fallback - use vfs methods
 
1068
            medium._remember_remote_is_before((1, 13))
 
1069
            return self._vfs_initialize(a_bzrdir, shared)
 
1070
        else:
 
1071
            # Turn the response into a RemoteRepository object.
 
1072
            format = response_tuple_to_repo_format(response[1:])
 
1073
            # Used to support creating a real format instance when needed.
 
1074
            format._creating_bzrdir = a_bzrdir
 
1075
            remote_repo = RemoteRepository(a_bzrdir, format)
 
1076
            format._creating_repo = remote_repo
 
1077
            return remote_repo
 
1078
 
 
1079
    def open(self, a_bzrdir):
 
1080
        if not isinstance(a_bzrdir, RemoteBzrDir):
 
1081
            raise AssertionError('%r is not a RemoteBzrDir' % (a_bzrdir,))
 
1082
        return a_bzrdir.open_repository()
 
1083
 
 
1084
    def _ensure_real(self):
 
1085
        if self._custom_format is None:
 
1086
            try:
 
1087
                self._custom_format = _mod_repository.network_format_registry.get(
 
1088
                    self._network_name)
 
1089
            except KeyError:
 
1090
                raise errors.UnknownFormatError(kind='repository',
 
1091
                    format=self._network_name)
 
1092
 
 
1093
    @property
 
1094
    def _fetch_order(self):
 
1095
        self._ensure_real()
 
1096
        return self._custom_format._fetch_order
 
1097
 
 
1098
    @property
 
1099
    def _fetch_uses_deltas(self):
 
1100
        self._ensure_real()
 
1101
        return self._custom_format._fetch_uses_deltas
 
1102
 
 
1103
    @property
 
1104
    def _fetch_reconcile(self):
 
1105
        self._ensure_real()
 
1106
        return self._custom_format._fetch_reconcile
 
1107
 
 
1108
    def get_format_description(self):
 
1109
        self._ensure_real()
 
1110
        return 'Remote: ' + self._custom_format.get_format_description()
 
1111
 
 
1112
    def __eq__(self, other):
 
1113
        return self.__class__ is other.__class__
 
1114
 
 
1115
    def network_name(self):
 
1116
        if self._network_name:
 
1117
            return self._network_name
 
1118
        self._creating_repo._ensure_real()
 
1119
        return self._creating_repo._real_repository._format.network_name()
 
1120
 
 
1121
    @property
 
1122
    def pack_compresses(self):
 
1123
        self._ensure_real()
 
1124
        return self._custom_format.pack_compresses
 
1125
 
 
1126
    @property
 
1127
    def _serializer(self):
 
1128
        self._ensure_real()
 
1129
        return self._custom_format._serializer
 
1130
 
 
1131
 
 
1132
class RemoteRepository(_mod_repository.Repository, _RpcHelper,
 
1133
        lock._RelockDebugMixin):
 
1134
    """Repository accessed over rpc.
 
1135
 
 
1136
    For the moment most operations are performed using local transport-backed
 
1137
    Repository objects.
 
1138
    """
 
1139
 
 
1140
    def __init__(self, remote_bzrdir, format, real_repository=None, _client=None):
 
1141
        """Create a RemoteRepository instance.
 
1142
 
 
1143
        :param remote_bzrdir: The bzrdir hosting this repository.
 
1144
        :param format: The RemoteFormat object to use.
 
1145
        :param real_repository: If not None, a local implementation of the
 
1146
            repository logic for the repository, usually accessing the data
 
1147
            via the VFS.
 
1148
        :param _client: Private testing parameter - override the smart client
 
1149
            to be used by the repository.
 
1150
        """
 
1151
        if real_repository:
 
1152
            self._real_repository = real_repository
 
1153
        else:
 
1154
            self._real_repository = None
 
1155
        self.bzrdir = remote_bzrdir
 
1156
        if _client is None:
 
1157
            self._client = remote_bzrdir._client
 
1158
        else:
 
1159
            self._client = _client
 
1160
        self._format = format
 
1161
        self._lock_mode = None
 
1162
        self._lock_token = None
 
1163
        self._write_group_tokens = None
 
1164
        self._lock_count = 0
 
1165
        self._leave_lock = False
 
1166
        # Cache of revision parents; misses are cached during read locks, and
 
1167
        # write locks when no _real_repository has been set.
 
1168
        self._unstacked_provider = graph.CachingParentsProvider(
 
1169
            get_parent_map=self._get_parent_map_rpc)
 
1170
        self._unstacked_provider.disable_cache()
 
1171
        # For tests:
 
1172
        # These depend on the actual remote format, so force them off for
 
1173
        # maximum compatibility. XXX: In future these should depend on the
 
1174
        # remote repository instance, but this is irrelevant until we perform
 
1175
        # reconcile via an RPC call.
 
1176
        self._reconcile_does_inventory_gc = False
 
1177
        self._reconcile_fixes_text_parents = False
 
1178
        self._reconcile_backsup_inventory = False
 
1179
        self.base = self.bzrdir.transport.base
 
1180
        # Additional places to query for data.
 
1181
        self._fallback_repositories = []
 
1182
 
 
1183
    @property
 
1184
    def user_transport(self):
 
1185
        return self.bzrdir.user_transport
 
1186
 
 
1187
    @property
 
1188
    def control_transport(self):
 
1189
        # XXX: Normally you shouldn't directly get at the remote repository
 
1190
        # transport, but I'm not sure it's worth making this method
 
1191
        # optional -- mbp 2010-04-21
 
1192
        return self.bzrdir.get_repository_transport(None)
 
1193
 
 
1194
    def __str__(self):
 
1195
        return "%s(%s)" % (self.__class__.__name__, self.base)
 
1196
 
 
1197
    __repr__ = __str__
 
1198
 
 
1199
    def abort_write_group(self, suppress_errors=False):
 
1200
        """Complete a write group on the decorated repository.
 
1201
 
 
1202
        Smart methods perform operations in a single step so this API
 
1203
        is not really applicable except as a compatibility thunk
 
1204
        for older plugins that don't use e.g. the CommitBuilder
 
1205
        facility.
 
1206
 
 
1207
        :param suppress_errors: see Repository.abort_write_group.
 
1208
        """
 
1209
        if self._real_repository:
 
1210
            self._ensure_real()
 
1211
            return self._real_repository.abort_write_group(
 
1212
                suppress_errors=suppress_errors)
 
1213
        if not self.is_in_write_group():
 
1214
            if suppress_errors:
 
1215
                mutter('(suppressed) not in write group')
 
1216
                return
 
1217
            raise errors.BzrError("not in write group")
 
1218
        path = self.bzrdir._path_for_remote_call(self._client)
 
1219
        try:
 
1220
            response = self._call('Repository.abort_write_group', path,
 
1221
                self._lock_token, self._write_group_tokens)
 
1222
        except Exception, exc:
 
1223
            self._write_group = None
 
1224
            if not suppress_errors:
 
1225
                raise
 
1226
            mutter('abort_write_group failed')
 
1227
            log_exception_quietly()
 
1228
            note(gettext('bzr: ERROR (ignored): %s'), exc)
 
1229
        else:
 
1230
            if response != ('ok', ):
 
1231
                raise errors.UnexpectedSmartServerResponse(response)
 
1232
            self._write_group_tokens = None
 
1233
 
 
1234
    @property
 
1235
    def chk_bytes(self):
 
1236
        """Decorate the real repository for now.
 
1237
 
 
1238
        In the long term a full blown network facility is needed to avoid
 
1239
        creating a real repository object locally.
 
1240
        """
 
1241
        self._ensure_real()
 
1242
        return self._real_repository.chk_bytes
 
1243
 
 
1244
    def commit_write_group(self):
 
1245
        """Complete a write group on the decorated repository.
 
1246
 
 
1247
        Smart methods perform operations in a single step so this API
 
1248
        is not really applicable except as a compatibility thunk
 
1249
        for older plugins that don't use e.g. the CommitBuilder
 
1250
        facility.
 
1251
        """
 
1252
        if self._real_repository:
 
1253
            self._ensure_real()
 
1254
            return self._real_repository.commit_write_group()
 
1255
        if not self.is_in_write_group():
 
1256
            raise errors.BzrError("not in write group")
 
1257
        path = self.bzrdir._path_for_remote_call(self._client)
 
1258
        response = self._call('Repository.commit_write_group', path,
 
1259
            self._lock_token, self._write_group_tokens)
 
1260
        if response != ('ok', ):
 
1261
            raise errors.UnexpectedSmartServerResponse(response)
 
1262
        self._write_group_tokens = None
 
1263
        # Refresh data after writing to the repository.
 
1264
        self.refresh_data()
 
1265
 
 
1266
    def resume_write_group(self, tokens):
 
1267
        if self._real_repository:
 
1268
            return self._real_repository.resume_write_group(tokens)
 
1269
        path = self.bzrdir._path_for_remote_call(self._client)
 
1270
        try:
 
1271
            response = self._call('Repository.check_write_group', path,
 
1272
               self._lock_token, tokens)
 
1273
        except errors.UnknownSmartMethod:
 
1274
            self._ensure_real()
 
1275
            return self._real_repository.resume_write_group(tokens)
 
1276
        if response != ('ok', ):
 
1277
            raise errors.UnexpectedSmartServerResponse(response)
 
1278
        self._write_group_tokens = tokens
 
1279
 
 
1280
    def suspend_write_group(self):
 
1281
        if self._real_repository:
 
1282
            return self._real_repository.suspend_write_group()
 
1283
        ret = self._write_group_tokens or []
 
1284
        self._write_group_tokens = None
 
1285
        return ret
 
1286
 
 
1287
    def get_missing_parent_inventories(self, check_for_missing_texts=True):
 
1288
        self._ensure_real()
 
1289
        return self._real_repository.get_missing_parent_inventories(
 
1290
            check_for_missing_texts=check_for_missing_texts)
 
1291
 
 
1292
    def _get_rev_id_for_revno_vfs(self, revno, known_pair):
 
1293
        self._ensure_real()
 
1294
        return self._real_repository.get_rev_id_for_revno(
 
1295
            revno, known_pair)
 
1296
 
 
1297
    def get_rev_id_for_revno(self, revno, known_pair):
 
1298
        """See Repository.get_rev_id_for_revno."""
 
1299
        path = self.bzrdir._path_for_remote_call(self._client)
 
1300
        try:
 
1301
            if self._client._medium._is_remote_before((1, 17)):
 
1302
                return self._get_rev_id_for_revno_vfs(revno, known_pair)
 
1303
            response = self._call(
 
1304
                'Repository.get_rev_id_for_revno', path, revno, known_pair)
 
1305
        except errors.UnknownSmartMethod:
 
1306
            self._client._medium._remember_remote_is_before((1, 17))
 
1307
            return self._get_rev_id_for_revno_vfs(revno, known_pair)
 
1308
        if response[0] == 'ok':
 
1309
            return True, response[1]
 
1310
        elif response[0] == 'history-incomplete':
 
1311
            known_pair = response[1:3]
 
1312
            for fallback in self._fallback_repositories:
 
1313
                found, result = fallback.get_rev_id_for_revno(revno, known_pair)
 
1314
                if found:
 
1315
                    return True, result
 
1316
                else:
 
1317
                    known_pair = result
 
1318
            # Not found in any fallbacks
 
1319
            return False, known_pair
 
1320
        else:
 
1321
            raise errors.UnexpectedSmartServerResponse(response)
 
1322
 
 
1323
    def _ensure_real(self):
 
1324
        """Ensure that there is a _real_repository set.
 
1325
 
 
1326
        Used before calls to self._real_repository.
 
1327
 
 
1328
        Note that _ensure_real causes many roundtrips to the server which are
 
1329
        not desirable, and prevents the use of smart one-roundtrip RPC's to
 
1330
        perform complex operations (such as accessing parent data, streaming
 
1331
        revisions etc). Adding calls to _ensure_real should only be done when
 
1332
        bringing up new functionality, adding fallbacks for smart methods that
 
1333
        require a fallback path, and never to replace an existing smart method
 
1334
        invocation. If in doubt chat to the bzr network team.
 
1335
        """
 
1336
        if self._real_repository is None:
 
1337
            if 'hpssvfs' in debug.debug_flags:
 
1338
                import traceback
 
1339
                warning('VFS Repository access triggered\n%s',
 
1340
                    ''.join(traceback.format_stack()))
 
1341
            self._unstacked_provider.missing_keys.clear()
 
1342
            self.bzrdir._ensure_real()
 
1343
            self._set_real_repository(
 
1344
                self.bzrdir._real_bzrdir.open_repository())
 
1345
 
 
1346
    def _translate_error(self, err, **context):
 
1347
        self.bzrdir._translate_error(err, repository=self, **context)
 
1348
 
 
1349
    def find_text_key_references(self):
 
1350
        """Find the text key references within the repository.
 
1351
 
 
1352
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
 
1353
            to whether they were referred to by the inventory of the
 
1354
            revision_id that they contain. The inventory texts from all present
 
1355
            revision ids are assessed to generate this report.
 
1356
        """
 
1357
        self._ensure_real()
 
1358
        return self._real_repository.find_text_key_references()
 
1359
 
 
1360
    def _generate_text_key_index(self):
 
1361
        """Generate a new text key index for the repository.
 
1362
 
 
1363
        This is an expensive function that will take considerable time to run.
 
1364
 
 
1365
        :return: A dict mapping (file_id, revision_id) tuples to a list of
 
1366
            parents, also (file_id, revision_id) tuples.
 
1367
        """
 
1368
        self._ensure_real()
 
1369
        return self._real_repository._generate_text_key_index()
 
1370
 
 
1371
    def _get_revision_graph(self, revision_id):
 
1372
        """Private method for using with old (< 1.2) servers to fallback."""
 
1373
        if revision_id is None:
 
1374
            revision_id = ''
 
1375
        elif _mod_revision.is_null(revision_id):
 
1376
            return {}
 
1377
 
 
1378
        path = self.bzrdir._path_for_remote_call(self._client)
 
1379
        response = self._call_expecting_body(
 
1380
            'Repository.get_revision_graph', path, revision_id)
 
1381
        response_tuple, response_handler = response
 
1382
        if response_tuple[0] != 'ok':
 
1383
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
1384
        coded = response_handler.read_body_bytes()
 
1385
        if coded == '':
 
1386
            # no revisions in this repository!
 
1387
            return {}
 
1388
        lines = coded.split('\n')
 
1389
        revision_graph = {}
 
1390
        for line in lines:
 
1391
            d = tuple(line.split())
 
1392
            revision_graph[d[0]] = d[1:]
 
1393
 
 
1394
        return revision_graph
 
1395
 
 
1396
    def _get_sink(self):
 
1397
        """See Repository._get_sink()."""
 
1398
        return RemoteStreamSink(self)
 
1399
 
 
1400
    def _get_source(self, to_format):
 
1401
        """Return a source for streaming from this repository."""
 
1402
        return RemoteStreamSource(self, to_format)
 
1403
 
 
1404
    @needs_read_lock
 
1405
    def get_file_graph(self):
 
1406
        return graph.Graph(self.texts)
 
1407
 
 
1408
    @needs_read_lock
 
1409
    def has_revision(self, revision_id):
 
1410
        """True if this repository has a copy of the revision."""
 
1411
        # Copy of bzrlib.repository.Repository.has_revision
 
1412
        return revision_id in self.has_revisions((revision_id,))
 
1413
 
 
1414
    @needs_read_lock
 
1415
    def has_revisions(self, revision_ids):
 
1416
        """Probe to find out the presence of multiple revisions.
 
1417
 
 
1418
        :param revision_ids: An iterable of revision_ids.
 
1419
        :return: A set of the revision_ids that were present.
 
1420
        """
 
1421
        # Copy of bzrlib.repository.Repository.has_revisions
 
1422
        parent_map = self.get_parent_map(revision_ids)
 
1423
        result = set(parent_map)
 
1424
        if _mod_revision.NULL_REVISION in revision_ids:
 
1425
            result.add(_mod_revision.NULL_REVISION)
 
1426
        return result
 
1427
 
 
1428
    def _has_same_fallbacks(self, other_repo):
 
1429
        """Returns true if the repositories have the same fallbacks."""
 
1430
        # XXX: copied from Repository; it should be unified into a base class
 
1431
        # <https://bugs.launchpad.net/bzr/+bug/401622>
 
1432
        my_fb = self._fallback_repositories
 
1433
        other_fb = other_repo._fallback_repositories
 
1434
        if len(my_fb) != len(other_fb):
 
1435
            return False
 
1436
        for f, g in zip(my_fb, other_fb):
 
1437
            if not f.has_same_location(g):
 
1438
                return False
 
1439
        return True
 
1440
 
 
1441
    def has_same_location(self, other):
 
1442
        # TODO: Move to RepositoryBase and unify with the regular Repository
 
1443
        # one; unfortunately the tests rely on slightly different behaviour at
 
1444
        # present -- mbp 20090710
 
1445
        return (self.__class__ is other.__class__ and
 
1446
                self.bzrdir.transport.base == other.bzrdir.transport.base)
 
1447
 
 
1448
    def get_graph(self, other_repository=None):
 
1449
        """Return the graph for this repository format"""
 
1450
        parents_provider = self._make_parents_provider(other_repository)
 
1451
        return graph.Graph(parents_provider)
 
1452
 
 
1453
    @needs_read_lock
 
1454
    def get_known_graph_ancestry(self, revision_ids):
 
1455
        """Return the known graph for a set of revision ids and their ancestors.
 
1456
        """
 
1457
        st = static_tuple.StaticTuple
 
1458
        revision_keys = [st(r_id).intern() for r_id in revision_ids]
 
1459
        known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
 
1460
        return graph.GraphThunkIdsToKeys(known_graph)
 
1461
 
 
1462
    def gather_stats(self, revid=None, committers=None):
 
1463
        """See Repository.gather_stats()."""
 
1464
        path = self.bzrdir._path_for_remote_call(self._client)
 
1465
        # revid can be None to indicate no revisions, not just NULL_REVISION
 
1466
        if revid is None or _mod_revision.is_null(revid):
 
1467
            fmt_revid = ''
 
1468
        else:
 
1469
            fmt_revid = revid
 
1470
        if committers is None or not committers:
 
1471
            fmt_committers = 'no'
 
1472
        else:
 
1473
            fmt_committers = 'yes'
 
1474
        response_tuple, response_handler = self._call_expecting_body(
 
1475
            'Repository.gather_stats', path, fmt_revid, fmt_committers)
 
1476
        if response_tuple[0] != 'ok':
 
1477
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
1478
 
 
1479
        body = response_handler.read_body_bytes()
 
1480
        result = {}
 
1481
        for line in body.split('\n'):
 
1482
            if not line:
 
1483
                continue
 
1484
            key, val_text = line.split(':')
 
1485
            if key in ('revisions', 'size', 'committers'):
 
1486
                result[key] = int(val_text)
 
1487
            elif key in ('firstrev', 'latestrev'):
 
1488
                values = val_text.split(' ')[1:]
 
1489
                result[key] = (float(values[0]), long(values[1]))
 
1490
 
 
1491
        return result
 
1492
 
 
1493
    def find_branches(self, using=False):
 
1494
        """See Repository.find_branches()."""
 
1495
        # should be an API call to the server.
 
1496
        self._ensure_real()
 
1497
        return self._real_repository.find_branches(using=using)
 
1498
 
 
1499
    def get_physical_lock_status(self):
 
1500
        """See Repository.get_physical_lock_status()."""
 
1501
        path = self.bzrdir._path_for_remote_call(self._client)
 
1502
        try:
 
1503
            response = self._call('Repository.get_physical_lock_status', path)
 
1504
        except errors.UnknownSmartMethod:
 
1505
            self._ensure_real()
 
1506
            return self._real_repository.get_physical_lock_status()
 
1507
        if response[0] not in ('yes', 'no'):
 
1508
            raise errors.UnexpectedSmartServerResponse(response)
 
1509
        return (response[0] == 'yes')
 
1510
 
 
1511
    def is_in_write_group(self):
 
1512
        """Return True if there is an open write group.
 
1513
 
 
1514
        write groups are only applicable locally for the smart server..
 
1515
        """
 
1516
        if self._write_group_tokens is not None:
 
1517
            return True
 
1518
        if self._real_repository:
 
1519
            return self._real_repository.is_in_write_group()
 
1520
 
 
1521
    def is_locked(self):
 
1522
        return self._lock_count >= 1
 
1523
 
 
1524
    def is_shared(self):
 
1525
        """See Repository.is_shared()."""
 
1526
        path = self.bzrdir._path_for_remote_call(self._client)
 
1527
        response = self._call('Repository.is_shared', path)
 
1528
        if response[0] not in ('yes', 'no'):
 
1529
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
1530
        return response[0] == 'yes'
 
1531
 
 
1532
    def is_write_locked(self):
 
1533
        return self._lock_mode == 'w'
 
1534
 
 
1535
    def _warn_if_deprecated(self, branch=None):
 
1536
        # If we have a real repository, the check will be done there, if we
 
1537
        # don't the check will be done remotely.
 
1538
        pass
 
1539
 
 
1540
    def lock_read(self):
 
1541
        """Lock the repository for read operations.
 
1542
 
 
1543
        :return: A bzrlib.lock.LogicalLockResult.
 
1544
        """
 
1545
        # wrong eventually - want a local lock cache context
 
1546
        if not self._lock_mode:
 
1547
            self._note_lock('r')
 
1548
            self._lock_mode = 'r'
 
1549
            self._lock_count = 1
 
1550
            self._unstacked_provider.enable_cache(cache_misses=True)
 
1551
            if self._real_repository is not None:
 
1552
                self._real_repository.lock_read()
 
1553
            for repo in self._fallback_repositories:
 
1554
                repo.lock_read()
 
1555
        else:
 
1556
            self._lock_count += 1
 
1557
        return lock.LogicalLockResult(self.unlock)
 
1558
 
 
1559
    def _remote_lock_write(self, token):
 
1560
        path = self.bzrdir._path_for_remote_call(self._client)
 
1561
        if token is None:
 
1562
            token = ''
 
1563
        err_context = {'token': token}
 
1564
        response = self._call('Repository.lock_write', path, token,
 
1565
                              **err_context)
 
1566
        if response[0] == 'ok':
 
1567
            ok, token = response
 
1568
            return token
 
1569
        else:
 
1570
            raise errors.UnexpectedSmartServerResponse(response)
 
1571
 
 
1572
    def lock_write(self, token=None, _skip_rpc=False):
 
1573
        if not self._lock_mode:
 
1574
            self._note_lock('w')
 
1575
            if _skip_rpc:
 
1576
                if self._lock_token is not None:
 
1577
                    if token != self._lock_token:
 
1578
                        raise errors.TokenMismatch(token, self._lock_token)
 
1579
                self._lock_token = token
 
1580
            else:
 
1581
                self._lock_token = self._remote_lock_write(token)
 
1582
            # if self._lock_token is None, then this is something like packs or
 
1583
            # svn where we don't get to lock the repo, or a weave style repository
 
1584
            # where we cannot lock it over the wire and attempts to do so will
 
1585
            # fail.
 
1586
            if self._real_repository is not None:
 
1587
                self._real_repository.lock_write(token=self._lock_token)
 
1588
            if token is not None:
 
1589
                self._leave_lock = True
 
1590
            else:
 
1591
                self._leave_lock = False
 
1592
            self._lock_mode = 'w'
 
1593
            self._lock_count = 1
 
1594
            cache_misses = self._real_repository is None
 
1595
            self._unstacked_provider.enable_cache(cache_misses=cache_misses)
 
1596
            for repo in self._fallback_repositories:
 
1597
                # Writes don't affect fallback repos
 
1598
                repo.lock_read()
 
1599
        elif self._lock_mode == 'r':
 
1600
            raise errors.ReadOnlyError(self)
 
1601
        else:
 
1602
            self._lock_count += 1
 
1603
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
 
1604
 
 
1605
    def leave_lock_in_place(self):
 
1606
        if not self._lock_token:
 
1607
            raise NotImplementedError(self.leave_lock_in_place)
 
1608
        self._leave_lock = True
 
1609
 
 
1610
    def dont_leave_lock_in_place(self):
 
1611
        if not self._lock_token:
 
1612
            raise NotImplementedError(self.dont_leave_lock_in_place)
 
1613
        self._leave_lock = False
 
1614
 
 
1615
    def _set_real_repository(self, repository):
 
1616
        """Set the _real_repository for this repository.
 
1617
 
 
1618
        :param repository: The repository to fallback to for non-hpss
 
1619
            implemented operations.
 
1620
        """
 
1621
        if self._real_repository is not None:
 
1622
            # Replacing an already set real repository.
 
1623
            # We cannot do this [currently] if the repository is locked -
 
1624
            # synchronised state might be lost.
 
1625
            if self.is_locked():
 
1626
                raise AssertionError('_real_repository is already set')
 
1627
        if isinstance(repository, RemoteRepository):
 
1628
            raise AssertionError()
 
1629
        self._real_repository = repository
 
1630
        # three code paths happen here:
 
1631
        # 1) old servers, RemoteBranch.open() calls _ensure_real before setting
 
1632
        # up stacking. In this case self._fallback_repositories is [], and the
 
1633
        # real repo is already setup. Preserve the real repo and
 
1634
        # RemoteRepository.add_fallback_repository will avoid adding
 
1635
        # duplicates.
 
1636
        # 2) new servers, RemoteBranch.open() sets up stacking, and when
 
1637
        # ensure_real is triggered from a branch, the real repository to
 
1638
        # set already has a matching list with separate instances, but
 
1639
        # as they are also RemoteRepositories we don't worry about making the
 
1640
        # lists be identical.
 
1641
        # 3) new servers, RemoteRepository.ensure_real is triggered before
 
1642
        # RemoteBranch.ensure real, in this case we get a repo with no fallbacks
 
1643
        # and need to populate it.
 
1644
        if (self._fallback_repositories and
 
1645
            len(self._real_repository._fallback_repositories) !=
 
1646
            len(self._fallback_repositories)):
 
1647
            if len(self._real_repository._fallback_repositories):
 
1648
                raise AssertionError(
 
1649
                    "cannot cleanly remove existing _fallback_repositories")
 
1650
        for fb in self._fallback_repositories:
 
1651
            self._real_repository.add_fallback_repository(fb)
 
1652
        if self._lock_mode == 'w':
 
1653
            # if we are already locked, the real repository must be able to
 
1654
            # acquire the lock with our token.
 
1655
            self._real_repository.lock_write(self._lock_token)
 
1656
        elif self._lock_mode == 'r':
 
1657
            self._real_repository.lock_read()
 
1658
        if self._write_group_tokens is not None:
 
1659
            # if we are already in a write group, resume it
 
1660
            self._real_repository.resume_write_group(self._write_group_tokens)
 
1661
            self._write_group_tokens = None
 
1662
 
 
1663
    def start_write_group(self):
 
1664
        """Start a write group on the decorated repository.
 
1665
 
 
1666
        Smart methods perform operations in a single step so this API
 
1667
        is not really applicable except as a compatibility thunk
 
1668
        for older plugins that don't use e.g. the CommitBuilder
 
1669
        facility.
 
1670
        """
 
1671
        if self._real_repository:
 
1672
            self._ensure_real()
 
1673
            return self._real_repository.start_write_group()
 
1674
        if not self.is_write_locked():
 
1675
            raise errors.NotWriteLocked(self)
 
1676
        if self._write_group_tokens is not None:
 
1677
            raise errors.BzrError('already in a write group')
 
1678
        path = self.bzrdir._path_for_remote_call(self._client)
 
1679
        try:
 
1680
            response = self._call('Repository.start_write_group', path,
 
1681
                self._lock_token)
 
1682
        except (errors.UnknownSmartMethod, errors.UnsuspendableWriteGroup):
 
1683
            self._ensure_real()
 
1684
            return self._real_repository.start_write_group()
 
1685
        if response[0] != 'ok':
 
1686
            raise errors.UnexpectedSmartServerResponse(response)
 
1687
        self._write_group_tokens = response[1]
 
1688
 
 
1689
    def _unlock(self, token):
 
1690
        path = self.bzrdir._path_for_remote_call(self._client)
 
1691
        if not token:
 
1692
            # with no token the remote repository is not persistently locked.
 
1693
            return
 
1694
        err_context = {'token': token}
 
1695
        response = self._call('Repository.unlock', path, token,
 
1696
                              **err_context)
 
1697
        if response == ('ok',):
 
1698
            return
 
1699
        else:
 
1700
            raise errors.UnexpectedSmartServerResponse(response)
 
1701
 
 
1702
    @only_raises(errors.LockNotHeld, errors.LockBroken)
 
1703
    def unlock(self):
 
1704
        if not self._lock_count:
 
1705
            return lock.cant_unlock_not_held(self)
 
1706
        self._lock_count -= 1
 
1707
        if self._lock_count > 0:
 
1708
            return
 
1709
        self._unstacked_provider.disable_cache()
 
1710
        old_mode = self._lock_mode
 
1711
        self._lock_mode = None
 
1712
        try:
 
1713
            # The real repository is responsible at present for raising an
 
1714
            # exception if it's in an unfinished write group.  However, it
 
1715
            # normally will *not* actually remove the lock from disk - that's
 
1716
            # done by the server on receiving the Repository.unlock call.
 
1717
            # This is just to let the _real_repository stay up to date.
 
1718
            if self._real_repository is not None:
 
1719
                self._real_repository.unlock()
 
1720
            elif self._write_group_tokens is not None:
 
1721
                self.abort_write_group()
 
1722
        finally:
 
1723
            # The rpc-level lock should be released even if there was a
 
1724
            # problem releasing the vfs-based lock.
 
1725
            if old_mode == 'w':
 
1726
                # Only write-locked repositories need to make a remote method
 
1727
                # call to perform the unlock.
 
1728
                old_token = self._lock_token
 
1729
                self._lock_token = None
 
1730
                if not self._leave_lock:
 
1731
                    self._unlock(old_token)
 
1732
        # Fallbacks are always 'lock_read()' so we don't pay attention to
 
1733
        # self._leave_lock
 
1734
        for repo in self._fallback_repositories:
 
1735
            repo.unlock()
 
1736
 
 
1737
    def break_lock(self):
 
1738
        # should hand off to the network
 
1739
        path = self.bzrdir._path_for_remote_call(self._client)
 
1740
        try:
 
1741
            response = self._call("Repository.break_lock", path)
 
1742
        except errors.UnknownSmartMethod:
 
1743
            self._ensure_real()
 
1744
            return self._real_repository.break_lock()
 
1745
        if response != ('ok',):
 
1746
            raise errors.UnexpectedSmartServerResponse(response)
 
1747
 
 
1748
    def _get_tarball(self, compression):
 
1749
        """Return a TemporaryFile containing a repository tarball.
 
1750
 
 
1751
        Returns None if the server does not support sending tarballs.
 
1752
        """
 
1753
        import tempfile
 
1754
        path = self.bzrdir._path_for_remote_call(self._client)
 
1755
        try:
 
1756
            response, protocol = self._call_expecting_body(
 
1757
                'Repository.tarball', path, compression)
 
1758
        except errors.UnknownSmartMethod:
 
1759
            protocol.cancel_read_body()
 
1760
            return None
 
1761
        if response[0] == 'ok':
 
1762
            # Extract the tarball and return it
 
1763
            t = tempfile.NamedTemporaryFile()
 
1764
            # TODO: rpc layer should read directly into it...
 
1765
            t.write(protocol.read_body_bytes())
 
1766
            t.seek(0)
 
1767
            return t
 
1768
        raise errors.UnexpectedSmartServerResponse(response)
 
1769
 
 
1770
    @needs_read_lock
 
1771
    def sprout(self, to_bzrdir, revision_id=None):
 
1772
        """Create a descendent repository for new development.
 
1773
 
 
1774
        Unlike clone, this does not copy the settings of the repository.
 
1775
        """
 
1776
        dest_repo = self._create_sprouting_repo(to_bzrdir, shared=False)
 
1777
        dest_repo.fetch(self, revision_id=revision_id)
 
1778
        return dest_repo
 
1779
 
 
1780
    def _create_sprouting_repo(self, a_bzrdir, shared):
 
1781
        if not isinstance(a_bzrdir._format, self.bzrdir._format.__class__):
 
1782
            # use target default format.
 
1783
            dest_repo = a_bzrdir.create_repository()
 
1784
        else:
 
1785
            # Most control formats need the repository to be specifically
 
1786
            # created, but on some old all-in-one formats it's not needed
 
1787
            try:
 
1788
                dest_repo = self._format.initialize(a_bzrdir, shared=shared)
 
1789
            except errors.UninitializableFormat:
 
1790
                dest_repo = a_bzrdir.open_repository()
 
1791
        return dest_repo
 
1792
 
 
1793
    ### These methods are just thin shims to the VFS object for now.
 
1794
 
 
1795
    @needs_read_lock
 
1796
    def revision_tree(self, revision_id):
 
1797
        revision_id = _mod_revision.ensure_null(revision_id)
 
1798
        if revision_id == _mod_revision.NULL_REVISION:
 
1799
            return InventoryRevisionTree(self,
 
1800
                Inventory(root_id=None), _mod_revision.NULL_REVISION)
 
1801
        else:
 
1802
            return list(self.revision_trees([revision_id]))[0]
 
1803
 
 
1804
    def get_serializer_format(self):
 
1805
        path = self.bzrdir._path_for_remote_call(self._client)
 
1806
        try:
 
1807
            response = self._call('VersionedFileRepository.get_serializer_format',
 
1808
                path)
 
1809
        except errors.UnknownSmartMethod:
 
1810
            self._ensure_real()
 
1811
            return self._real_repository.get_serializer_format()
 
1812
        if response[0] != 'ok':
 
1813
            raise errors.UnexpectedSmartServerResponse(response)
 
1814
        return response[1]
 
1815
 
 
1816
    def get_commit_builder(self, branch, parents, config, timestamp=None,
 
1817
                           timezone=None, committer=None, revprops=None,
 
1818
                           revision_id=None, lossy=False):
 
1819
        """Obtain a CommitBuilder for this repository.
 
1820
 
 
1821
        :param branch: Branch to commit to.
 
1822
        :param parents: Revision ids of the parents of the new revision.
 
1823
        :param config: Configuration to use.
 
1824
        :param timestamp: Optional timestamp recorded for commit.
 
1825
        :param timezone: Optional timezone for timestamp.
 
1826
        :param committer: Optional committer to set for commit.
 
1827
        :param revprops: Optional dictionary of revision properties.
 
1828
        :param revision_id: Optional revision id.
 
1829
        :param lossy: Whether to discard data that can not be natively
 
1830
            represented, when pushing to a foreign VCS
 
1831
        """
 
1832
        if self._fallback_repositories and not self._format.supports_chks:
 
1833
            raise errors.BzrError("Cannot commit directly to a stacked branch"
 
1834
                " in pre-2a formats. See "
 
1835
                "https://bugs.launchpad.net/bzr/+bug/375013 for details.")
 
1836
        if self._format.rich_root_data:
 
1837
            commit_builder_kls = vf_repository.VersionedFileRootCommitBuilder
 
1838
        else:
 
1839
            commit_builder_kls = vf_repository.VersionedFileCommitBuilder
 
1840
        result = commit_builder_kls(self, parents, config,
 
1841
            timestamp, timezone, committer, revprops, revision_id,
 
1842
            lossy)
 
1843
        self.start_write_group()
 
1844
        return result
 
1845
 
 
1846
    def add_fallback_repository(self, repository):
 
1847
        """Add a repository to use for looking up data not held locally.
 
1848
 
 
1849
        :param repository: A repository.
 
1850
        """
 
1851
        if not self._format.supports_external_lookups:
 
1852
            raise errors.UnstackableRepositoryFormat(
 
1853
                self._format.network_name(), self.base)
 
1854
        # We need to accumulate additional repositories here, to pass them in
 
1855
        # on various RPC's.
 
1856
        #
 
1857
        # Make the check before we lock: this raises an exception.
 
1858
        self._check_fallback_repository(repository)
 
1859
        if self.is_locked():
 
1860
            # We will call fallback.unlock() when we transition to the unlocked
 
1861
            # state, so always add a lock here. If a caller passes us a locked
 
1862
            # repository, they are responsible for unlocking it later.
 
1863
            repository.lock_read()
 
1864
        self._fallback_repositories.append(repository)
 
1865
        # If self._real_repository was parameterised already (e.g. because a
 
1866
        # _real_branch had its get_stacked_on_url method called), then the
 
1867
        # repository to be added may already be in the _real_repositories list.
 
1868
        if self._real_repository is not None:
 
1869
            fallback_locations = [repo.user_url for repo in
 
1870
                self._real_repository._fallback_repositories]
 
1871
            if repository.user_url not in fallback_locations:
 
1872
                self._real_repository.add_fallback_repository(repository)
 
1873
 
 
1874
    def _check_fallback_repository(self, repository):
 
1875
        """Check that this repository can fallback to repository safely.
 
1876
 
 
1877
        Raise an error if not.
 
1878
 
 
1879
        :param repository: A repository to fallback to.
 
1880
        """
 
1881
        return _mod_repository.InterRepository._assert_same_model(
 
1882
            self, repository)
 
1883
 
 
1884
    def add_inventory(self, revid, inv, parents):
 
1885
        self._ensure_real()
 
1886
        return self._real_repository.add_inventory(revid, inv, parents)
 
1887
 
 
1888
    def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
 
1889
            parents, basis_inv=None, propagate_caches=False):
 
1890
        self._ensure_real()
 
1891
        return self._real_repository.add_inventory_by_delta(basis_revision_id,
 
1892
            delta, new_revision_id, parents, basis_inv=basis_inv,
 
1893
            propagate_caches=propagate_caches)
 
1894
 
 
1895
    def add_revision(self, revision_id, rev, inv=None):
 
1896
        _mod_revision.check_not_reserved_id(revision_id)
 
1897
        key = (revision_id,)
 
1898
        # check inventory present
 
1899
        if not self.inventories.get_parent_map([key]):
 
1900
            if inv is None:
 
1901
                raise errors.WeaveRevisionNotPresent(revision_id,
 
1902
                                                     self.inventories)
 
1903
            else:
 
1904
                # yes, this is not suitable for adding with ghosts.
 
1905
                rev.inventory_sha1 = self.add_inventory(revision_id, inv,
 
1906
                                                        rev.parent_ids)
 
1907
        else:
 
1908
            rev.inventory_sha1 = self.inventories.get_sha1s([key])[key]
 
1909
        self._add_revision(rev)
 
1910
 
 
1911
    def _add_revision(self, rev):
 
1912
        if self._real_repository is not None:
 
1913
            return self._real_repository._add_revision(rev)
 
1914
        text = self._serializer.write_revision_to_string(rev)
 
1915
        key = (rev.revision_id,)
 
1916
        parents = tuple((parent,) for parent in rev.parent_ids)
 
1917
        self._write_group_tokens, missing_keys = self._get_sink().insert_stream(
 
1918
            [('revisions', [FulltextContentFactory(key, parents, None, text)])],
 
1919
            self._format, self._write_group_tokens)
 
1920
 
 
1921
    @needs_read_lock
 
1922
    def get_inventory(self, revision_id):
 
1923
        return list(self.iter_inventories([revision_id]))[0]
 
1924
 
 
1925
    def _iter_inventories_rpc(self, revision_ids, ordering):
 
1926
        if ordering is None:
 
1927
            ordering = 'unordered'
 
1928
        path = self.bzrdir._path_for_remote_call(self._client)
 
1929
        body = "\n".join(revision_ids)
 
1930
        response_tuple, response_handler = (
 
1931
            self._call_with_body_bytes_expecting_body(
 
1932
                "VersionedFileRepository.get_inventories",
 
1933
                (path, ordering), body))
 
1934
        if response_tuple[0] != "ok":
 
1935
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
1936
        deserializer = inventory_delta.InventoryDeltaDeserializer()
 
1937
        byte_stream = response_handler.read_streamed_body()
 
1938
        decoded = smart_repo._byte_stream_to_stream(byte_stream)
 
1939
        if decoded is None:
 
1940
            # no results whatsoever
 
1941
            return
 
1942
        src_format, stream = decoded
 
1943
        if src_format.network_name() != self._format.network_name():
 
1944
            raise AssertionError(
 
1945
                "Mismatched RemoteRepository and stream src %r, %r" % (
 
1946
                src_format.network_name(), self._format.network_name()))
 
1947
        # ignore the src format, it's not really relevant
 
1948
        prev_inv = Inventory(root_id=None,
 
1949
            revision_id=_mod_revision.NULL_REVISION)
 
1950
        # there should be just one substream, with inventory deltas
 
1951
        substream_kind, substream = stream.next()
 
1952
        if substream_kind != "inventory-deltas":
 
1953
            raise AssertionError(
 
1954
                 "Unexpected stream %r received" % substream_kind)
 
1955
        for record in substream:
 
1956
            (parent_id, new_id, versioned_root, tree_references, invdelta) = (
 
1957
                deserializer.parse_text_bytes(record.get_bytes_as("fulltext")))
 
1958
            if parent_id != prev_inv.revision_id:
 
1959
                raise AssertionError("invalid base %r != %r" % (parent_id,
 
1960
                    prev_inv.revision_id))
 
1961
            inv = prev_inv.create_by_apply_delta(invdelta, new_id)
 
1962
            yield inv, inv.revision_id
 
1963
            prev_inv = inv
 
1964
 
 
1965
    def _iter_inventories_vfs(self, revision_ids, ordering=None):
 
1966
        self._ensure_real()
 
1967
        return self._real_repository._iter_inventories(revision_ids, ordering)
 
1968
 
 
1969
    def iter_inventories(self, revision_ids, ordering=None):
 
1970
        """Get many inventories by revision_ids.
 
1971
 
 
1972
        This will buffer some or all of the texts used in constructing the
 
1973
        inventories in memory, but will only parse a single inventory at a
 
1974
        time.
 
1975
 
 
1976
        :param revision_ids: The expected revision ids of the inventories.
 
1977
        :param ordering: optional ordering, e.g. 'topological'.  If not
 
1978
            specified, the order of revision_ids will be preserved (by
 
1979
            buffering if necessary).
 
1980
        :return: An iterator of inventories.
 
1981
        """
 
1982
        if ((None in revision_ids)
 
1983
            or (_mod_revision.NULL_REVISION in revision_ids)):
 
1984
            raise ValueError('cannot get null revision inventory')
 
1985
        for inv, revid in self._iter_inventories(revision_ids, ordering):
 
1986
            if inv is None:
 
1987
                raise errors.NoSuchRevision(self, revid)
 
1988
            yield inv
 
1989
 
 
1990
    def _iter_inventories(self, revision_ids, ordering=None):
 
1991
        if len(revision_ids) == 0:
 
1992
            return
 
1993
        missing = set(revision_ids)
 
1994
        if ordering is None:
 
1995
            order_as_requested = True
 
1996
            invs = {}
 
1997
            order = list(revision_ids)
 
1998
            order.reverse()
 
1999
            next_revid = order.pop()
 
2000
        else:
 
2001
            order_as_requested = False
 
2002
            if ordering != 'unordered' and self._fallback_repositories:
 
2003
                raise ValueError('unsupported ordering %r' % ordering)
 
2004
        iter_inv_fns = [self._iter_inventories_rpc] + [
 
2005
            fallback._iter_inventories for fallback in
 
2006
            self._fallback_repositories]
 
2007
        try:
 
2008
            for iter_inv in iter_inv_fns:
 
2009
                request = [revid for revid in revision_ids if revid in missing]
 
2010
                for inv, revid in iter_inv(request, ordering):
 
2011
                    if inv is None:
 
2012
                        continue
 
2013
                    missing.remove(inv.revision_id)
 
2014
                    if ordering != 'unordered':
 
2015
                        invs[revid] = inv
 
2016
                    else:
 
2017
                        yield inv, revid
 
2018
                if order_as_requested:
 
2019
                    # Yield as many results as we can while preserving order.
 
2020
                    while next_revid in invs:
 
2021
                        inv = invs.pop(next_revid)
 
2022
                        yield inv, inv.revision_id
 
2023
                        try:
 
2024
                            next_revid = order.pop()
 
2025
                        except IndexError:
 
2026
                            # We still want to fully consume the stream, just
 
2027
                            # in case it is not actually finished at this point
 
2028
                            next_revid = None
 
2029
                            break
 
2030
        except errors.UnknownSmartMethod:
 
2031
            for inv, revid in self._iter_inventories_vfs(revision_ids, ordering):
 
2032
                yield inv, revid
 
2033
            return
 
2034
        # Report missing
 
2035
        if order_as_requested:
 
2036
            if next_revid is not None:
 
2037
                yield None, next_revid
 
2038
            while order:
 
2039
                revid = order.pop()
 
2040
                yield invs.get(revid), revid
 
2041
        else:
 
2042
            while missing:
 
2043
                yield None, missing.pop()
 
2044
 
 
2045
    @needs_read_lock
 
2046
    def get_revision(self, revision_id):
 
2047
        return self.get_revisions([revision_id])[0]
 
2048
 
 
2049
    def get_transaction(self):
 
2050
        self._ensure_real()
 
2051
        return self._real_repository.get_transaction()
 
2052
 
 
2053
    @needs_read_lock
 
2054
    def clone(self, a_bzrdir, revision_id=None):
 
2055
        dest_repo = self._create_sprouting_repo(
 
2056
            a_bzrdir, shared=self.is_shared())
 
2057
        self.copy_content_into(dest_repo, revision_id)
 
2058
        return dest_repo
 
2059
 
 
2060
    def make_working_trees(self):
 
2061
        """See Repository.make_working_trees"""
 
2062
        path = self.bzrdir._path_for_remote_call(self._client)
 
2063
        try:
 
2064
            response = self._call('Repository.make_working_trees', path)
 
2065
        except errors.UnknownSmartMethod:
 
2066
            self._ensure_real()
 
2067
            return self._real_repository.make_working_trees()
 
2068
        if response[0] not in ('yes', 'no'):
 
2069
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
2070
        return response[0] == 'yes'
 
2071
 
 
2072
    def refresh_data(self):
 
2073
        """Re-read any data needed to synchronise with disk.
 
2074
 
 
2075
        This method is intended to be called after another repository instance
 
2076
        (such as one used by a smart server) has inserted data into the
 
2077
        repository. On all repositories this will work outside of write groups.
 
2078
        Some repository formats (pack and newer for bzrlib native formats)
 
2079
        support refresh_data inside write groups. If called inside a write
 
2080
        group on a repository that does not support refreshing in a write group
 
2081
        IsInWriteGroupError will be raised.
 
2082
        """
 
2083
        if self._real_repository is not None:
 
2084
            self._real_repository.refresh_data()
 
2085
        # Refresh the parents cache for this object
 
2086
        self._unstacked_provider.disable_cache()
 
2087
        self._unstacked_provider.enable_cache()
 
2088
 
 
2089
    def revision_ids_to_search_result(self, result_set):
 
2090
        """Convert a set of revision ids to a graph SearchResult."""
 
2091
        result_parents = set()
 
2092
        for parents in self.get_graph().get_parent_map(
 
2093
            result_set).itervalues():
 
2094
            result_parents.update(parents)
 
2095
        included_keys = result_set.intersection(result_parents)
 
2096
        start_keys = result_set.difference(included_keys)
 
2097
        exclude_keys = result_parents.difference(result_set)
 
2098
        result = vf_search.SearchResult(start_keys, exclude_keys,
 
2099
            len(result_set), result_set)
 
2100
        return result
 
2101
 
 
2102
    @needs_read_lock
 
2103
    def search_missing_revision_ids(self, other,
 
2104
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
 
2105
            find_ghosts=True, revision_ids=None, if_present_ids=None,
 
2106
            limit=None):
 
2107
        """Return the revision ids that other has that this does not.
 
2108
 
 
2109
        These are returned in topological order.
 
2110
 
 
2111
        revision_id: only return revision ids included by revision_id.
 
2112
        """
 
2113
        if symbol_versioning.deprecated_passed(revision_id):
 
2114
            symbol_versioning.warn(
 
2115
                'search_missing_revision_ids(revision_id=...) was '
 
2116
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
 
2117
                DeprecationWarning, stacklevel=2)
 
2118
            if revision_ids is not None:
 
2119
                raise AssertionError(
 
2120
                    'revision_ids is mutually exclusive with revision_id')
 
2121
            if revision_id is not None:
 
2122
                revision_ids = [revision_id]
 
2123
        inter_repo = _mod_repository.InterRepository.get(other, self)
 
2124
        return inter_repo.search_missing_revision_ids(
 
2125
            find_ghosts=find_ghosts, revision_ids=revision_ids,
 
2126
            if_present_ids=if_present_ids, limit=limit)
 
2127
 
 
2128
    def fetch(self, source, revision_id=None, find_ghosts=False,
 
2129
            fetch_spec=None):
 
2130
        # No base implementation to use as RemoteRepository is not a subclass
 
2131
        # of Repository; so this is a copy of Repository.fetch().
 
2132
        if fetch_spec is not None and revision_id is not None:
 
2133
            raise AssertionError(
 
2134
                "fetch_spec and revision_id are mutually exclusive.")
 
2135
        if self.is_in_write_group():
 
2136
            raise errors.InternalBzrError(
 
2137
                "May not fetch while in a write group.")
 
2138
        # fast path same-url fetch operations
 
2139
        if (self.has_same_location(source)
 
2140
            and fetch_spec is None
 
2141
            and self._has_same_fallbacks(source)):
 
2142
            # check that last_revision is in 'from' and then return a
 
2143
            # no-operation.
 
2144
            if (revision_id is not None and
 
2145
                not _mod_revision.is_null(revision_id)):
 
2146
                self.get_revision(revision_id)
 
2147
            return 0, []
 
2148
        # if there is no specific appropriate InterRepository, this will get
 
2149
        # the InterRepository base class, which raises an
 
2150
        # IncompatibleRepositories when asked to fetch.
 
2151
        inter = _mod_repository.InterRepository.get(source, self)
 
2152
        if (fetch_spec is not None and
 
2153
            not getattr(inter, "supports_fetch_spec", False)):
 
2154
            raise errors.UnsupportedOperation(
 
2155
                "fetch_spec not supported for %r" % inter)
 
2156
        return inter.fetch(revision_id=revision_id,
 
2157
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
 
2158
 
 
2159
    def create_bundle(self, target, base, fileobj, format=None):
 
2160
        self._ensure_real()
 
2161
        self._real_repository.create_bundle(target, base, fileobj, format)
 
2162
 
 
2163
    @needs_read_lock
 
2164
    @symbol_versioning.deprecated_method(
 
2165
        symbol_versioning.deprecated_in((2, 4, 0)))
 
2166
    def get_ancestry(self, revision_id, topo_sorted=True):
 
2167
        self._ensure_real()
 
2168
        return self._real_repository.get_ancestry(revision_id, topo_sorted)
 
2169
 
 
2170
    def fileids_altered_by_revision_ids(self, revision_ids):
 
2171
        self._ensure_real()
 
2172
        return self._real_repository.fileids_altered_by_revision_ids(revision_ids)
 
2173
 
 
2174
    def _get_versioned_file_checker(self, revisions, revision_versions_cache):
 
2175
        self._ensure_real()
 
2176
        return self._real_repository._get_versioned_file_checker(
 
2177
            revisions, revision_versions_cache)
 
2178
 
 
2179
    def _iter_files_bytes_rpc(self, desired_files, absent):
 
2180
        path = self.bzrdir._path_for_remote_call(self._client)
 
2181
        lines = []
 
2182
        identifiers = []
 
2183
        for (file_id, revid, identifier) in desired_files:
 
2184
            lines.append("%s\0%s" % (
 
2185
                osutils.safe_file_id(file_id),
 
2186
                osutils.safe_revision_id(revid)))
 
2187
            identifiers.append(identifier)
 
2188
        (response_tuple, response_handler) = (
 
2189
            self._call_with_body_bytes_expecting_body(
 
2190
            "Repository.iter_files_bytes", (path, ), "\n".join(lines)))
 
2191
        if response_tuple != ('ok', ):
 
2192
            response_handler.cancel_read_body()
 
2193
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2194
        byte_stream = response_handler.read_streamed_body()
 
2195
        def decompress_stream(start, byte_stream, unused):
 
2196
            decompressor = zlib.decompressobj()
 
2197
            yield decompressor.decompress(start)
 
2198
            while decompressor.unused_data == "":
 
2199
                try:
 
2200
                    data = byte_stream.next()
 
2201
                except StopIteration:
 
2202
                    break
 
2203
                yield decompressor.decompress(data)
 
2204
            yield decompressor.flush()
 
2205
            unused.append(decompressor.unused_data)
 
2206
        unused = ""
 
2207
        while True:
 
2208
            while not "\n" in unused:
 
2209
                unused += byte_stream.next()
 
2210
            header, rest = unused.split("\n", 1)
 
2211
            args = header.split("\0")
 
2212
            if args[0] == "absent":
 
2213
                absent[identifiers[int(args[3])]] = (args[1], args[2])
 
2214
                unused = rest
 
2215
                continue
 
2216
            elif args[0] == "ok":
 
2217
                idx = int(args[1])
 
2218
            else:
 
2219
                raise errors.UnexpectedSmartServerResponse(args)
 
2220
            unused_chunks = []
 
2221
            yield (identifiers[idx],
 
2222
                decompress_stream(rest, byte_stream, unused_chunks))
 
2223
            unused = "".join(unused_chunks)
 
2224
 
 
2225
    def iter_files_bytes(self, desired_files):
 
2226
        """See Repository.iter_file_bytes.
 
2227
        """
 
2228
        try:
 
2229
            absent = {}
 
2230
            for (identifier, bytes_iterator) in self._iter_files_bytes_rpc(
 
2231
                    desired_files, absent):
 
2232
                yield identifier, bytes_iterator
 
2233
            for fallback in self._fallback_repositories:
 
2234
                if not absent:
 
2235
                    break
 
2236
                desired_files = [(key[0], key[1], identifier) for
 
2237
                    (identifier, key) in absent.iteritems()]
 
2238
                for (identifier, bytes_iterator) in fallback.iter_files_bytes(desired_files):
 
2239
                    del absent[identifier]
 
2240
                    yield identifier, bytes_iterator
 
2241
            if absent:
 
2242
                # There may be more missing items, but raise an exception
 
2243
                # for just one.
 
2244
                missing_identifier = absent.keys()[0]
 
2245
                missing_key = absent[missing_identifier]
 
2246
                raise errors.RevisionNotPresent(revision_id=missing_key[1],
 
2247
                    file_id=missing_key[0])
 
2248
        except errors.UnknownSmartMethod:
 
2249
            self._ensure_real()
 
2250
            for (identifier, bytes_iterator) in (
 
2251
                self._real_repository.iter_files_bytes(desired_files)):
 
2252
                yield identifier, bytes_iterator
 
2253
 
 
2254
    def get_cached_parent_map(self, revision_ids):
 
2255
        """See bzrlib.CachingParentsProvider.get_cached_parent_map"""
 
2256
        return self._unstacked_provider.get_cached_parent_map(revision_ids)
 
2257
 
 
2258
    def get_parent_map(self, revision_ids):
 
2259
        """See bzrlib.Graph.get_parent_map()."""
 
2260
        return self._make_parents_provider().get_parent_map(revision_ids)
 
2261
 
 
2262
    def _get_parent_map_rpc(self, keys):
 
2263
        """Helper for get_parent_map that performs the RPC."""
 
2264
        medium = self._client._medium
 
2265
        if medium._is_remote_before((1, 2)):
 
2266
            # We already found out that the server can't understand
 
2267
            # Repository.get_parent_map requests, so just fetch the whole
 
2268
            # graph.
 
2269
            #
 
2270
            # Note that this reads the whole graph, when only some keys are
 
2271
            # wanted.  On this old server there's no way (?) to get them all
 
2272
            # in one go, and the user probably will have seen a warning about
 
2273
            # the server being old anyhow.
 
2274
            rg = self._get_revision_graph(None)
 
2275
            # There is an API discrepancy between get_parent_map and
 
2276
            # get_revision_graph. Specifically, a "key:()" pair in
 
2277
            # get_revision_graph just means a node has no parents. For
 
2278
            # "get_parent_map" it means the node is a ghost. So fix up the
 
2279
            # graph to correct this.
 
2280
            #   https://bugs.launchpad.net/bzr/+bug/214894
 
2281
            # There is one other "bug" which is that ghosts in
 
2282
            # get_revision_graph() are not returned at all. But we won't worry
 
2283
            # about that for now.
 
2284
            for node_id, parent_ids in rg.iteritems():
 
2285
                if parent_ids == ():
 
2286
                    rg[node_id] = (NULL_REVISION,)
 
2287
            rg[NULL_REVISION] = ()
 
2288
            return rg
 
2289
 
 
2290
        keys = set(keys)
 
2291
        if None in keys:
 
2292
            raise ValueError('get_parent_map(None) is not valid')
 
2293
        if NULL_REVISION in keys:
 
2294
            keys.discard(NULL_REVISION)
 
2295
            found_parents = {NULL_REVISION:()}
 
2296
            if not keys:
 
2297
                return found_parents
 
2298
        else:
 
2299
            found_parents = {}
 
2300
        # TODO(Needs analysis): We could assume that the keys being requested
 
2301
        # from get_parent_map are in a breadth first search, so typically they
 
2302
        # will all be depth N from some common parent, and we don't have to
 
2303
        # have the server iterate from the root parent, but rather from the
 
2304
        # keys we're searching; and just tell the server the keyspace we
 
2305
        # already have; but this may be more traffic again.
 
2306
 
 
2307
        # Transform self._parents_map into a search request recipe.
 
2308
        # TODO: Manage this incrementally to avoid covering the same path
 
2309
        # repeatedly. (The server will have to on each request, but the less
 
2310
        # work done the better).
 
2311
        #
 
2312
        # Negative caching notes:
 
2313
        # new server sends missing when a request including the revid
 
2314
        # 'include-missing:' is present in the request.
 
2315
        # missing keys are serialised as missing:X, and we then call
 
2316
        # provider.note_missing(X) for-all X
 
2317
        parents_map = self._unstacked_provider.get_cached_map()
 
2318
        if parents_map is None:
 
2319
            # Repository is not locked, so there's no cache.
 
2320
            parents_map = {}
 
2321
        if _DEFAULT_SEARCH_DEPTH <= 0:
 
2322
            (start_set, stop_keys,
 
2323
             key_count) = vf_search.search_result_from_parent_map(
 
2324
                parents_map, self._unstacked_provider.missing_keys)
 
2325
        else:
 
2326
            (start_set, stop_keys,
 
2327
             key_count) = vf_search.limited_search_result_from_parent_map(
 
2328
                parents_map, self._unstacked_provider.missing_keys,
 
2329
                keys, depth=_DEFAULT_SEARCH_DEPTH)
 
2330
        recipe = ('manual', start_set, stop_keys, key_count)
 
2331
        body = self._serialise_search_recipe(recipe)
 
2332
        path = self.bzrdir._path_for_remote_call(self._client)
 
2333
        for key in keys:
 
2334
            if type(key) is not str:
 
2335
                raise ValueError(
 
2336
                    "key %r not a plain string" % (key,))
 
2337
        verb = 'Repository.get_parent_map'
 
2338
        args = (path, 'include-missing:') + tuple(keys)
 
2339
        try:
 
2340
            response = self._call_with_body_bytes_expecting_body(
 
2341
                verb, args, body)
 
2342
        except errors.UnknownSmartMethod:
 
2343
            # Server does not support this method, so get the whole graph.
 
2344
            # Worse, we have to force a disconnection, because the server now
 
2345
            # doesn't realise it has a body on the wire to consume, so the
 
2346
            # only way to recover is to abandon the connection.
 
2347
            warning(
 
2348
                'Server is too old for fast get_parent_map, reconnecting.  '
 
2349
                '(Upgrade the server to Bazaar 1.2 to avoid this)')
 
2350
            medium.disconnect()
 
2351
            # To avoid having to disconnect repeatedly, we keep track of the
 
2352
            # fact the server doesn't understand remote methods added in 1.2.
 
2353
            medium._remember_remote_is_before((1, 2))
 
2354
            # Recurse just once and we should use the fallback code.
 
2355
            return self._get_parent_map_rpc(keys)
 
2356
        response_tuple, response_handler = response
 
2357
        if response_tuple[0] not in ['ok']:
 
2358
            response_handler.cancel_read_body()
 
2359
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2360
        if response_tuple[0] == 'ok':
 
2361
            coded = bz2.decompress(response_handler.read_body_bytes())
 
2362
            if coded == '':
 
2363
                # no revisions found
 
2364
                return {}
 
2365
            lines = coded.split('\n')
 
2366
            revision_graph = {}
 
2367
            for line in lines:
 
2368
                d = tuple(line.split())
 
2369
                if len(d) > 1:
 
2370
                    revision_graph[d[0]] = d[1:]
 
2371
                else:
 
2372
                    # No parents:
 
2373
                    if d[0].startswith('missing:'):
 
2374
                        revid = d[0][8:]
 
2375
                        self._unstacked_provider.note_missing_key(revid)
 
2376
                    else:
 
2377
                        # no parents - so give the Graph result
 
2378
                        # (NULL_REVISION,).
 
2379
                        revision_graph[d[0]] = (NULL_REVISION,)
 
2380
            return revision_graph
 
2381
 
 
2382
    @needs_read_lock
 
2383
    def get_signature_text(self, revision_id):
 
2384
        path = self.bzrdir._path_for_remote_call(self._client)
 
2385
        try:
 
2386
            response_tuple, response_handler = self._call_expecting_body(
 
2387
                'Repository.get_revision_signature_text', path, revision_id)
 
2388
        except errors.UnknownSmartMethod:
 
2389
            self._ensure_real()
 
2390
            return self._real_repository.get_signature_text(revision_id)
 
2391
        except errors.NoSuchRevision, err:
 
2392
            for fallback in self._fallback_repositories:
 
2393
                try:
 
2394
                    return fallback.get_signature_text(revision_id)
 
2395
                except errors.NoSuchRevision:
 
2396
                    pass
 
2397
            raise err
 
2398
        else:
 
2399
            if response_tuple[0] != 'ok':
 
2400
                raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2401
            return response_handler.read_body_bytes()
 
2402
 
 
2403
    @needs_read_lock
 
2404
    def _get_inventory_xml(self, revision_id):
 
2405
        # This call is used by older working tree formats,
 
2406
        # which stored a serialized basis inventory.
 
2407
        self._ensure_real()
 
2408
        return self._real_repository._get_inventory_xml(revision_id)
 
2409
 
 
2410
    @needs_write_lock
 
2411
    def reconcile(self, other=None, thorough=False):
 
2412
        from bzrlib.reconcile import RepoReconciler
 
2413
        path = self.bzrdir._path_for_remote_call(self._client)
 
2414
        try:
 
2415
            response, handler = self._call_expecting_body(
 
2416
                'Repository.reconcile', path, self._lock_token)
 
2417
        except (errors.UnknownSmartMethod, errors.TokenLockingNotSupported):
 
2418
            self._ensure_real()
 
2419
            return self._real_repository.reconcile(other=other, thorough=thorough)
 
2420
        if response != ('ok', ):
 
2421
            raise errors.UnexpectedSmartServerResponse(response)
 
2422
        body = handler.read_body_bytes()
 
2423
        result = RepoReconciler(self)
 
2424
        for line in body.split('\n'):
 
2425
            if not line:
 
2426
                continue
 
2427
            key, val_text = line.split(':')
 
2428
            if key == "garbage_inventories":
 
2429
                result.garbage_inventories = int(val_text)
 
2430
            elif key == "inconsistent_parents":
 
2431
                result.inconsistent_parents = int(val_text)
 
2432
            else:
 
2433
                mutter("unknown reconcile key %r" % key)
 
2434
        return result
 
2435
 
 
2436
    def all_revision_ids(self):
 
2437
        path = self.bzrdir._path_for_remote_call(self._client)
 
2438
        try:
 
2439
            response_tuple, response_handler = self._call_expecting_body(
 
2440
                "Repository.all_revision_ids", path)
 
2441
        except errors.UnknownSmartMethod:
 
2442
            self._ensure_real()
 
2443
            return self._real_repository.all_revision_ids()
 
2444
        if response_tuple != ("ok", ):
 
2445
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2446
        revids = set(response_handler.read_body_bytes().splitlines())
 
2447
        for fallback in self._fallback_repositories:
 
2448
            revids.update(set(fallback.all_revision_ids()))
 
2449
        return list(revids)
 
2450
 
 
2451
    def _filtered_revision_trees(self, revision_ids, file_ids):
 
2452
        """Return Tree for a revision on this branch with only some files.
 
2453
 
 
2454
        :param revision_ids: a sequence of revision-ids;
 
2455
          a revision-id may not be None or 'null:'
 
2456
        :param file_ids: if not None, the result is filtered
 
2457
          so that only those file-ids, their parents and their
 
2458
          children are included.
 
2459
        """
 
2460
        inventories = self.iter_inventories(revision_ids)
 
2461
        for inv in inventories:
 
2462
            # Should we introduce a FilteredRevisionTree class rather
 
2463
            # than pre-filter the inventory here?
 
2464
            filtered_inv = inv.filter(file_ids)
 
2465
            yield InventoryRevisionTree(self, filtered_inv, filtered_inv.revision_id)
 
2466
 
 
2467
    @needs_read_lock
 
2468
    def get_deltas_for_revisions(self, revisions, specific_fileids=None):
 
2469
        medium = self._client._medium
 
2470
        if medium._is_remote_before((1, 2)):
 
2471
            self._ensure_real()
 
2472
            for delta in self._real_repository.get_deltas_for_revisions(
 
2473
                    revisions, specific_fileids):
 
2474
                yield delta
 
2475
            return
 
2476
        # Get the revision-ids of interest
 
2477
        required_trees = set()
 
2478
        for revision in revisions:
 
2479
            required_trees.add(revision.revision_id)
 
2480
            required_trees.update(revision.parent_ids[:1])
 
2481
 
 
2482
        # Get the matching filtered trees. Note that it's more
 
2483
        # efficient to pass filtered trees to changes_from() rather
 
2484
        # than doing the filtering afterwards. changes_from() could
 
2485
        # arguably do the filtering itself but it's path-based, not
 
2486
        # file-id based, so filtering before or afterwards is
 
2487
        # currently easier.
 
2488
        if specific_fileids is None:
 
2489
            trees = dict((t.get_revision_id(), t) for
 
2490
                t in self.revision_trees(required_trees))
 
2491
        else:
 
2492
            trees = dict((t.get_revision_id(), t) for
 
2493
                t in self._filtered_revision_trees(required_trees,
 
2494
                specific_fileids))
 
2495
 
 
2496
        # Calculate the deltas
 
2497
        for revision in revisions:
 
2498
            if not revision.parent_ids:
 
2499
                old_tree = self.revision_tree(_mod_revision.NULL_REVISION)
 
2500
            else:
 
2501
                old_tree = trees[revision.parent_ids[0]]
 
2502
            yield trees[revision.revision_id].changes_from(old_tree)
 
2503
 
 
2504
    @needs_read_lock
 
2505
    def get_revision_delta(self, revision_id, specific_fileids=None):
 
2506
        r = self.get_revision(revision_id)
 
2507
        return list(self.get_deltas_for_revisions([r],
 
2508
            specific_fileids=specific_fileids))[0]
 
2509
 
 
2510
    @needs_read_lock
 
2511
    def revision_trees(self, revision_ids):
 
2512
        inventories = self.iter_inventories(revision_ids)
 
2513
        for inv in inventories:
 
2514
            yield InventoryRevisionTree(self, inv, inv.revision_id)
 
2515
 
 
2516
    @needs_read_lock
 
2517
    def get_revision_reconcile(self, revision_id):
 
2518
        self._ensure_real()
 
2519
        return self._real_repository.get_revision_reconcile(revision_id)
 
2520
 
 
2521
    @needs_read_lock
 
2522
    def check(self, revision_ids=None, callback_refs=None, check_repo=True):
 
2523
        self._ensure_real()
 
2524
        return self._real_repository.check(revision_ids=revision_ids,
 
2525
            callback_refs=callback_refs, check_repo=check_repo)
 
2526
 
 
2527
    def copy_content_into(self, destination, revision_id=None):
 
2528
        """Make a complete copy of the content in self into destination.
 
2529
 
 
2530
        This is a destructive operation! Do not use it on existing
 
2531
        repositories.
 
2532
        """
 
2533
        interrepo = _mod_repository.InterRepository.get(self, destination)
 
2534
        return interrepo.copy_content(revision_id)
 
2535
 
 
2536
    def _copy_repository_tarball(self, to_bzrdir, revision_id=None):
 
2537
        # get a tarball of the remote repository, and copy from that into the
 
2538
        # destination
 
2539
        import tarfile
 
2540
        # TODO: Maybe a progress bar while streaming the tarball?
 
2541
        note(gettext("Copying repository content as tarball..."))
 
2542
        tar_file = self._get_tarball('bz2')
 
2543
        if tar_file is None:
 
2544
            return None
 
2545
        destination = to_bzrdir.create_repository()
 
2546
        try:
 
2547
            tar = tarfile.open('repository', fileobj=tar_file,
 
2548
                mode='r|bz2')
 
2549
            tmpdir = osutils.mkdtemp()
 
2550
            try:
 
2551
                _extract_tar(tar, tmpdir)
 
2552
                tmp_bzrdir = _mod_bzrdir.BzrDir.open(tmpdir)
 
2553
                tmp_repo = tmp_bzrdir.open_repository()
 
2554
                tmp_repo.copy_content_into(destination, revision_id)
 
2555
            finally:
 
2556
                osutils.rmtree(tmpdir)
 
2557
        finally:
 
2558
            tar_file.close()
 
2559
        return destination
 
2560
        # TODO: Suggestion from john: using external tar is much faster than
 
2561
        # python's tarfile library, but it may not work on windows.
 
2562
 
 
2563
    @property
 
2564
    def inventories(self):
 
2565
        """Decorate the real repository for now.
 
2566
 
 
2567
        In the long term a full blown network facility is needed to
 
2568
        avoid creating a real repository object locally.
 
2569
        """
 
2570
        self._ensure_real()
 
2571
        return self._real_repository.inventories
 
2572
 
 
2573
    @needs_write_lock
 
2574
    def pack(self, hint=None, clean_obsolete_packs=False):
 
2575
        """Compress the data within the repository.
 
2576
        """
 
2577
        if hint is None:
 
2578
            body = ""
 
2579
        else:
 
2580
            body = "".join([l+"\n" for l in hint])
 
2581
        path = self.bzrdir._path_for_remote_call(self._client)
 
2582
        try:
 
2583
            response, handler = self._call_with_body_bytes_expecting_body(
 
2584
                'Repository.pack', (path, self._lock_token,
 
2585
                    str(clean_obsolete_packs)), body)
 
2586
        except errors.UnknownSmartMethod:
 
2587
            self._ensure_real()
 
2588
            return self._real_repository.pack(hint=hint,
 
2589
                clean_obsolete_packs=clean_obsolete_packs)
 
2590
        handler.cancel_read_body()
 
2591
        if response != ('ok', ):
 
2592
            raise errors.UnexpectedSmartServerResponse(response)
 
2593
 
 
2594
    @property
 
2595
    def revisions(self):
 
2596
        """Decorate the real repository for now.
 
2597
 
 
2598
        In the long term a full blown network facility is needed.
 
2599
        """
 
2600
        self._ensure_real()
 
2601
        return self._real_repository.revisions
 
2602
 
 
2603
    def set_make_working_trees(self, new_value):
 
2604
        if new_value:
 
2605
            new_value_str = "True"
 
2606
        else:
 
2607
            new_value_str = "False"
 
2608
        path = self.bzrdir._path_for_remote_call(self._client)
 
2609
        try:
 
2610
            response = self._call(
 
2611
                'Repository.set_make_working_trees', path, new_value_str)
 
2612
        except errors.UnknownSmartMethod:
 
2613
            self._ensure_real()
 
2614
            self._real_repository.set_make_working_trees(new_value)
 
2615
        else:
 
2616
            if response[0] != 'ok':
 
2617
                raise errors.UnexpectedSmartServerResponse(response)
 
2618
 
 
2619
    @property
 
2620
    def signatures(self):
 
2621
        """Decorate the real repository for now.
 
2622
 
 
2623
        In the long term a full blown network facility is needed to avoid
 
2624
        creating a real repository object locally.
 
2625
        """
 
2626
        self._ensure_real()
 
2627
        return self._real_repository.signatures
 
2628
 
 
2629
    @needs_write_lock
 
2630
    def sign_revision(self, revision_id, gpg_strategy):
 
2631
        testament = _mod_testament.Testament.from_revision(self, revision_id)
 
2632
        plaintext = testament.as_short_text()
 
2633
        self.store_revision_signature(gpg_strategy, plaintext, revision_id)
 
2634
 
 
2635
    @property
 
2636
    def texts(self):
 
2637
        """Decorate the real repository for now.
 
2638
 
 
2639
        In the long term a full blown network facility is needed to avoid
 
2640
        creating a real repository object locally.
 
2641
        """
 
2642
        self._ensure_real()
 
2643
        return self._real_repository.texts
 
2644
 
 
2645
    def _iter_revisions_rpc(self, revision_ids):
 
2646
        body = "\n".join(revision_ids)
 
2647
        path = self.bzrdir._path_for_remote_call(self._client)
 
2648
        response_tuple, response_handler = (
 
2649
            self._call_with_body_bytes_expecting_body(
 
2650
            "Repository.iter_revisions", (path, ), body))
 
2651
        if response_tuple[0] != "ok":
 
2652
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2653
        serializer_format = response_tuple[1]
 
2654
        serializer = serializer_format_registry.get(serializer_format)
 
2655
        byte_stream = response_handler.read_streamed_body()
 
2656
        decompressor = zlib.decompressobj()
 
2657
        chunks = []
 
2658
        for bytes in byte_stream:
 
2659
            chunks.append(decompressor.decompress(bytes))
 
2660
            if decompressor.unused_data != "":
 
2661
                chunks.append(decompressor.flush())
 
2662
                yield serializer.read_revision_from_string("".join(chunks))
 
2663
                unused = decompressor.unused_data
 
2664
                decompressor = zlib.decompressobj()
 
2665
                chunks = [decompressor.decompress(unused)]
 
2666
        chunks.append(decompressor.flush())
 
2667
        text = "".join(chunks)
 
2668
        if text != "":
 
2669
            yield serializer.read_revision_from_string("".join(chunks))
 
2670
 
 
2671
    @needs_read_lock
 
2672
    def get_revisions(self, revision_ids):
 
2673
        if revision_ids is None:
 
2674
            revision_ids = self.all_revision_ids()
 
2675
        else:
 
2676
            for rev_id in revision_ids:
 
2677
                if not rev_id or not isinstance(rev_id, basestring):
 
2678
                    raise errors.InvalidRevisionId(
 
2679
                        revision_id=rev_id, branch=self)
 
2680
        try:
 
2681
            missing = set(revision_ids)
 
2682
            revs = {}
 
2683
            for rev in self._iter_revisions_rpc(revision_ids):
 
2684
                missing.remove(rev.revision_id)
 
2685
                revs[rev.revision_id] = rev
 
2686
        except errors.UnknownSmartMethod:
 
2687
            self._ensure_real()
 
2688
            return self._real_repository.get_revisions(revision_ids)
 
2689
        for fallback in self._fallback_repositories:
 
2690
            if not missing:
 
2691
                break
 
2692
            for revid in list(missing):
 
2693
                # XXX JRV 2011-11-20: It would be nice if there was a
 
2694
                # public method on Repository that could be used to query
 
2695
                # for revision objects *without* failing completely if one
 
2696
                # was missing. There is VersionedFileRepository._iter_revisions,
 
2697
                # but unfortunately that's private and not provided by
 
2698
                # all repository implementations.
 
2699
                try:
 
2700
                    revs[revid] = fallback.get_revision(revid)
 
2701
                except errors.NoSuchRevision:
 
2702
                    pass
 
2703
                else:
 
2704
                    missing.remove(revid)
 
2705
        if missing:
 
2706
            raise errors.NoSuchRevision(self, list(missing)[0])
 
2707
        return [revs[revid] for revid in revision_ids]
 
2708
 
 
2709
    def supports_rich_root(self):
 
2710
        return self._format.rich_root_data
 
2711
 
 
2712
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
 
2713
    def iter_reverse_revision_history(self, revision_id):
 
2714
        self._ensure_real()
 
2715
        return self._real_repository.iter_reverse_revision_history(revision_id)
 
2716
 
 
2717
    @property
 
2718
    def _serializer(self):
 
2719
        return self._format._serializer
 
2720
 
 
2721
    @needs_write_lock
 
2722
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
 
2723
        signature = gpg_strategy.sign(plaintext)
 
2724
        self.add_signature_text(revision_id, signature)
 
2725
 
 
2726
    def add_signature_text(self, revision_id, signature):
 
2727
        if self._real_repository:
 
2728
            # If there is a real repository the write group will
 
2729
            # be in the real repository as well, so use that:
 
2730
            self._ensure_real()
 
2731
            return self._real_repository.add_signature_text(
 
2732
                revision_id, signature)
 
2733
        path = self.bzrdir._path_for_remote_call(self._client)
 
2734
        response, handler = self._call_with_body_bytes_expecting_body(
 
2735
            'Repository.add_signature_text', (path, self._lock_token,
 
2736
                revision_id) + tuple(self._write_group_tokens), signature)
 
2737
        handler.cancel_read_body()
 
2738
        self.refresh_data()
 
2739
        if response[0] != 'ok':
 
2740
            raise errors.UnexpectedSmartServerResponse(response)
 
2741
        self._write_group_tokens = response[1:]
 
2742
 
 
2743
    def has_signature_for_revision_id(self, revision_id):
 
2744
        path = self.bzrdir._path_for_remote_call(self._client)
 
2745
        try:
 
2746
            response = self._call('Repository.has_signature_for_revision_id',
 
2747
                path, revision_id)
 
2748
        except errors.UnknownSmartMethod:
 
2749
            self._ensure_real()
 
2750
            return self._real_repository.has_signature_for_revision_id(
 
2751
                revision_id)
 
2752
        if response[0] not in ('yes', 'no'):
 
2753
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
2754
        if response[0] == 'yes':
 
2755
            return True
 
2756
        for fallback in self._fallback_repositories:
 
2757
            if fallback.has_signature_for_revision_id(revision_id):
 
2758
                return True
 
2759
        return False
 
2760
 
 
2761
    @needs_read_lock
 
2762
    def verify_revision_signature(self, revision_id, gpg_strategy):
 
2763
        if not self.has_signature_for_revision_id(revision_id):
 
2764
            return gpg.SIGNATURE_NOT_SIGNED, None
 
2765
        signature = self.get_signature_text(revision_id)
 
2766
 
 
2767
        testament = _mod_testament.Testament.from_revision(self, revision_id)
 
2768
        plaintext = testament.as_short_text()
 
2769
 
 
2770
        return gpg_strategy.verify(signature, plaintext)
 
2771
 
 
2772
    def item_keys_introduced_by(self, revision_ids, _files_pb=None):
 
2773
        self._ensure_real()
 
2774
        return self._real_repository.item_keys_introduced_by(revision_ids,
 
2775
            _files_pb=_files_pb)
 
2776
 
 
2777
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
 
2778
        self._ensure_real()
 
2779
        return self._real_repository._find_inconsistent_revision_parents(
 
2780
            revisions_iterator)
 
2781
 
 
2782
    def _check_for_inconsistent_revision_parents(self):
 
2783
        self._ensure_real()
 
2784
        return self._real_repository._check_for_inconsistent_revision_parents()
 
2785
 
 
2786
    def _make_parents_provider(self, other=None):
 
2787
        providers = [self._unstacked_provider]
 
2788
        if other is not None:
 
2789
            providers.insert(0, other)
 
2790
        return graph.StackedParentsProvider(_LazyListJoin(
 
2791
            providers, self._fallback_repositories))
 
2792
 
 
2793
    def _serialise_search_recipe(self, recipe):
 
2794
        """Serialise a graph search recipe.
 
2795
 
 
2796
        :param recipe: A search recipe (start, stop, count).
 
2797
        :return: Serialised bytes.
 
2798
        """
 
2799
        start_keys = ' '.join(recipe[1])
 
2800
        stop_keys = ' '.join(recipe[2])
 
2801
        count = str(recipe[3])
 
2802
        return '\n'.join((start_keys, stop_keys, count))
 
2803
 
 
2804
    def _serialise_search_result(self, search_result):
 
2805
        parts = search_result.get_network_struct()
 
2806
        return '\n'.join(parts)
 
2807
 
 
2808
    def autopack(self):
 
2809
        path = self.bzrdir._path_for_remote_call(self._client)
 
2810
        try:
 
2811
            response = self._call('PackRepository.autopack', path)
 
2812
        except errors.UnknownSmartMethod:
 
2813
            self._ensure_real()
 
2814
            self._real_repository._pack_collection.autopack()
 
2815
            return
 
2816
        self.refresh_data()
 
2817
        if response[0] != 'ok':
 
2818
            raise errors.UnexpectedSmartServerResponse(response)
 
2819
 
 
2820
 
 
2821
class RemoteStreamSink(vf_repository.StreamSink):
 
2822
 
 
2823
    def _insert_real(self, stream, src_format, resume_tokens):
 
2824
        self.target_repo._ensure_real()
 
2825
        sink = self.target_repo._real_repository._get_sink()
 
2826
        result = sink.insert_stream(stream, src_format, resume_tokens)
 
2827
        if not result:
 
2828
            self.target_repo.autopack()
 
2829
        return result
 
2830
 
 
2831
    def insert_stream(self, stream, src_format, resume_tokens):
 
2832
        target = self.target_repo
 
2833
        target._unstacked_provider.missing_keys.clear()
 
2834
        candidate_calls = [('Repository.insert_stream_1.19', (1, 19))]
 
2835
        if target._lock_token:
 
2836
            candidate_calls.append(('Repository.insert_stream_locked', (1, 14)))
 
2837
            lock_args = (target._lock_token or '',)
 
2838
        else:
 
2839
            candidate_calls.append(('Repository.insert_stream', (1, 13)))
 
2840
            lock_args = ()
 
2841
        client = target._client
 
2842
        medium = client._medium
 
2843
        path = target.bzrdir._path_for_remote_call(client)
 
2844
        # Probe for the verb to use with an empty stream before sending the
 
2845
        # real stream to it.  We do this both to avoid the risk of sending a
 
2846
        # large request that is then rejected, and because we don't want to
 
2847
        # implement a way to buffer, rewind, or restart the stream.
 
2848
        found_verb = False
 
2849
        for verb, required_version in candidate_calls:
 
2850
            if medium._is_remote_before(required_version):
 
2851
                continue
 
2852
            if resume_tokens:
 
2853
                # We've already done the probing (and set _is_remote_before) on
 
2854
                # a previous insert.
 
2855
                found_verb = True
 
2856
                break
 
2857
            byte_stream = smart_repo._stream_to_byte_stream([], src_format)
 
2858
            try:
 
2859
                response = client.call_with_body_stream(
 
2860
                    (verb, path, '') + lock_args, byte_stream)
 
2861
            except errors.UnknownSmartMethod:
 
2862
                medium._remember_remote_is_before(required_version)
 
2863
            else:
 
2864
                found_verb = True
 
2865
                break
 
2866
        if not found_verb:
 
2867
            # Have to use VFS.
 
2868
            return self._insert_real(stream, src_format, resume_tokens)
 
2869
        self._last_inv_record = None
 
2870
        self._last_substream = None
 
2871
        if required_version < (1, 19):
 
2872
            # Remote side doesn't support inventory deltas.  Wrap the stream to
 
2873
            # make sure we don't send any.  If the stream contains inventory
 
2874
            # deltas we'll interrupt the smart insert_stream request and
 
2875
            # fallback to VFS.
 
2876
            stream = self._stop_stream_if_inventory_delta(stream)
 
2877
        byte_stream = smart_repo._stream_to_byte_stream(
 
2878
            stream, src_format)
 
2879
        resume_tokens = ' '.join(resume_tokens)
 
2880
        response = client.call_with_body_stream(
 
2881
            (verb, path, resume_tokens) + lock_args, byte_stream)
 
2882
        if response[0][0] not in ('ok', 'missing-basis'):
 
2883
            raise errors.UnexpectedSmartServerResponse(response)
 
2884
        if self._last_substream is not None:
 
2885
            # The stream included an inventory-delta record, but the remote
 
2886
            # side isn't new enough to support them.  So we need to send the
 
2887
            # rest of the stream via VFS.
 
2888
            self.target_repo.refresh_data()
 
2889
            return self._resume_stream_with_vfs(response, src_format)
 
2890
        if response[0][0] == 'missing-basis':
 
2891
            tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
 
2892
            resume_tokens = tokens
 
2893
            return resume_tokens, set(missing_keys)
 
2894
        else:
 
2895
            self.target_repo.refresh_data()
 
2896
            return [], set()
 
2897
 
 
2898
    def _resume_stream_with_vfs(self, response, src_format):
 
2899
        """Resume sending a stream via VFS, first resending the record and
 
2900
        substream that couldn't be sent via an insert_stream verb.
 
2901
        """
 
2902
        if response[0][0] == 'missing-basis':
 
2903
            tokens, missing_keys = bencode.bdecode_as_tuple(response[0][1])
 
2904
            # Ignore missing_keys, we haven't finished inserting yet
 
2905
        else:
 
2906
            tokens = []
 
2907
        def resume_substream():
 
2908
            # Yield the substream that was interrupted.
 
2909
            for record in self._last_substream:
 
2910
                yield record
 
2911
            self._last_substream = None
 
2912
        def resume_stream():
 
2913
            # Finish sending the interrupted substream
 
2914
            yield ('inventory-deltas', resume_substream())
 
2915
            # Then simply continue sending the rest of the stream.
 
2916
            for substream_kind, substream in self._last_stream:
 
2917
                yield substream_kind, substream
 
2918
        return self._insert_real(resume_stream(), src_format, tokens)
 
2919
 
 
2920
    def _stop_stream_if_inventory_delta(self, stream):
 
2921
        """Normally this just lets the original stream pass-through unchanged.
 
2922
 
 
2923
        However if any 'inventory-deltas' substream occurs it will stop
 
2924
        streaming, and store the interrupted substream and stream in
 
2925
        self._last_substream and self._last_stream so that the stream can be
 
2926
        resumed by _resume_stream_with_vfs.
 
2927
        """
 
2928
 
 
2929
        stream_iter = iter(stream)
 
2930
        for substream_kind, substream in stream_iter:
 
2931
            if substream_kind == 'inventory-deltas':
 
2932
                self._last_substream = substream
 
2933
                self._last_stream = stream_iter
 
2934
                return
 
2935
            else:
 
2936
                yield substream_kind, substream
 
2937
 
 
2938
 
 
2939
class RemoteStreamSource(vf_repository.StreamSource):
 
2940
    """Stream data from a remote server."""
 
2941
 
 
2942
    def get_stream(self, search):
 
2943
        if (self.from_repository._fallback_repositories and
 
2944
            self.to_format._fetch_order == 'topological'):
 
2945
            return self._real_stream(self.from_repository, search)
 
2946
        sources = []
 
2947
        seen = set()
 
2948
        repos = [self.from_repository]
 
2949
        while repos:
 
2950
            repo = repos.pop(0)
 
2951
            if repo in seen:
 
2952
                continue
 
2953
            seen.add(repo)
 
2954
            repos.extend(repo._fallback_repositories)
 
2955
            sources.append(repo)
 
2956
        return self.missing_parents_chain(search, sources)
 
2957
 
 
2958
    def get_stream_for_missing_keys(self, missing_keys):
 
2959
        self.from_repository._ensure_real()
 
2960
        real_repo = self.from_repository._real_repository
 
2961
        real_source = real_repo._get_source(self.to_format)
 
2962
        return real_source.get_stream_for_missing_keys(missing_keys)
 
2963
 
 
2964
    def _real_stream(self, repo, search):
 
2965
        """Get a stream for search from repo.
 
2966
 
 
2967
        This never called RemoteStreamSource.get_stream, and is a helper
 
2968
        for RemoteStreamSource._get_stream to allow getting a stream
 
2969
        reliably whether fallback back because of old servers or trying
 
2970
        to stream from a non-RemoteRepository (which the stacked support
 
2971
        code will do).
 
2972
        """
 
2973
        source = repo._get_source(self.to_format)
 
2974
        if isinstance(source, RemoteStreamSource):
 
2975
            repo._ensure_real()
 
2976
            source = repo._real_repository._get_source(self.to_format)
 
2977
        return source.get_stream(search)
 
2978
 
 
2979
    def _get_stream(self, repo, search):
 
2980
        """Core worker to get a stream from repo for search.
 
2981
 
 
2982
        This is used by both get_stream and the stacking support logic. It
 
2983
        deliberately gets a stream for repo which does not need to be
 
2984
        self.from_repository. In the event that repo is not Remote, or
 
2985
        cannot do a smart stream, a fallback is made to the generic
 
2986
        repository._get_stream() interface, via self._real_stream.
 
2987
 
 
2988
        In the event of stacking, streams from _get_stream will not
 
2989
        contain all the data for search - this is normal (see get_stream).
 
2990
 
 
2991
        :param repo: A repository.
 
2992
        :param search: A search.
 
2993
        """
 
2994
        # Fallbacks may be non-smart
 
2995
        if not isinstance(repo, RemoteRepository):
 
2996
            return self._real_stream(repo, search)
 
2997
        client = repo._client
 
2998
        medium = client._medium
 
2999
        path = repo.bzrdir._path_for_remote_call(client)
 
3000
        search_bytes = repo._serialise_search_result(search)
 
3001
        args = (path, self.to_format.network_name())
 
3002
        candidate_verbs = [
 
3003
            ('Repository.get_stream_1.19', (1, 19)),
 
3004
            ('Repository.get_stream', (1, 13))]
 
3005
 
 
3006
        found_verb = False
 
3007
        for verb, version in candidate_verbs:
 
3008
            if medium._is_remote_before(version):
 
3009
                continue
 
3010
            try:
 
3011
                response = repo._call_with_body_bytes_expecting_body(
 
3012
                    verb, args, search_bytes)
 
3013
            except errors.UnknownSmartMethod:
 
3014
                medium._remember_remote_is_before(version)
 
3015
            except errors.UnknownErrorFromSmartServer, e:
 
3016
                if isinstance(search, vf_search.EverythingResult):
 
3017
                    error_verb = e.error_from_smart_server.error_verb
 
3018
                    if error_verb == 'BadSearch':
 
3019
                        # Pre-2.4 servers don't support this sort of search.
 
3020
                        # XXX: perhaps falling back to VFS on BadSearch is a
 
3021
                        # good idea in general?  It might provide a little bit
 
3022
                        # of protection against client-side bugs.
 
3023
                        medium._remember_remote_is_before((2, 4))
 
3024
                        break
 
3025
                raise
 
3026
            else:
 
3027
                response_tuple, response_handler = response
 
3028
                found_verb = True
 
3029
                break
 
3030
        if not found_verb:
 
3031
            return self._real_stream(repo, search)
 
3032
        if response_tuple[0] != 'ok':
 
3033
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
3034
        byte_stream = response_handler.read_streamed_body()
 
3035
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
 
3036
            self._record_counter)
 
3037
        if src_format.network_name() != repo._format.network_name():
 
3038
            raise AssertionError(
 
3039
                "Mismatched RemoteRepository and stream src %r, %r" % (
 
3040
                src_format.network_name(), repo._format.network_name()))
 
3041
        return stream
 
3042
 
 
3043
    def missing_parents_chain(self, search, sources):
 
3044
        """Chain multiple streams together to handle stacking.
 
3045
 
 
3046
        :param search: The overall search to satisfy with streams.
 
3047
        :param sources: A list of Repository objects to query.
 
3048
        """
 
3049
        self.from_serialiser = self.from_repository._format._serializer
 
3050
        self.seen_revs = set()
 
3051
        self.referenced_revs = set()
 
3052
        # If there are heads in the search, or the key count is > 0, we are not
 
3053
        # done.
 
3054
        while not search.is_empty() and len(sources) > 1:
 
3055
            source = sources.pop(0)
 
3056
            stream = self._get_stream(source, search)
 
3057
            for kind, substream in stream:
 
3058
                if kind != 'revisions':
 
3059
                    yield kind, substream
 
3060
                else:
 
3061
                    yield kind, self.missing_parents_rev_handler(substream)
 
3062
            search = search.refine(self.seen_revs, self.referenced_revs)
 
3063
            self.seen_revs = set()
 
3064
            self.referenced_revs = set()
 
3065
        if not search.is_empty():
 
3066
            for kind, stream in self._get_stream(sources[0], search):
 
3067
                yield kind, stream
 
3068
 
 
3069
    def missing_parents_rev_handler(self, substream):
 
3070
        for content in substream:
 
3071
            revision_bytes = content.get_bytes_as('fulltext')
 
3072
            revision = self.from_serialiser.read_revision_from_string(
 
3073
                revision_bytes)
 
3074
            self.seen_revs.add(content.key[-1])
 
3075
            self.referenced_revs.update(revision.parent_ids)
 
3076
            yield content
 
3077
 
 
3078
 
 
3079
class RemoteBranchLockableFiles(LockableFiles):
 
3080
    """A 'LockableFiles' implementation that talks to a smart server.
 
3081
 
 
3082
    This is not a public interface class.
 
3083
    """
 
3084
 
 
3085
    def __init__(self, bzrdir, _client):
 
3086
        self.bzrdir = bzrdir
 
3087
        self._client = _client
 
3088
        self._need_find_modes = True
 
3089
        LockableFiles.__init__(
 
3090
            self, bzrdir.get_branch_transport(None),
 
3091
            'lock', lockdir.LockDir)
 
3092
 
 
3093
    def _find_modes(self):
 
3094
        # RemoteBranches don't let the client set the mode of control files.
 
3095
        self._dir_mode = None
 
3096
        self._file_mode = None
 
3097
 
 
3098
 
 
3099
class RemoteBranchFormat(branch.BranchFormat):
 
3100
 
 
3101
    def __init__(self, network_name=None):
 
3102
        super(RemoteBranchFormat, self).__init__()
 
3103
        self._matchingbzrdir = RemoteBzrDirFormat()
 
3104
        self._matchingbzrdir.set_branch_format(self)
 
3105
        self._custom_format = None
 
3106
        self._network_name = network_name
 
3107
 
 
3108
    def __eq__(self, other):
 
3109
        return (isinstance(other, RemoteBranchFormat) and
 
3110
            self.__dict__ == other.__dict__)
 
3111
 
 
3112
    def _ensure_real(self):
 
3113
        if self._custom_format is None:
 
3114
            try:
 
3115
                self._custom_format = branch.network_format_registry.get(
 
3116
                    self._network_name)
 
3117
            except KeyError:
 
3118
                raise errors.UnknownFormatError(kind='branch',
 
3119
                    format=self._network_name)
 
3120
 
 
3121
    def get_format_description(self):
 
3122
        self._ensure_real()
 
3123
        return 'Remote: ' + self._custom_format.get_format_description()
 
3124
 
 
3125
    def network_name(self):
 
3126
        return self._network_name
 
3127
 
 
3128
    def open(self, a_bzrdir, name=None, ignore_fallbacks=False):
 
3129
        return a_bzrdir.open_branch(name=name, 
 
3130
            ignore_fallbacks=ignore_fallbacks)
 
3131
 
 
3132
    def _vfs_initialize(self, a_bzrdir, name, append_revisions_only):
 
3133
        # Initialisation when using a local bzrdir object, or a non-vfs init
 
3134
        # method is not available on the server.
 
3135
        # self._custom_format is always set - the start of initialize ensures
 
3136
        # that.
 
3137
        if isinstance(a_bzrdir, RemoteBzrDir):
 
3138
            a_bzrdir._ensure_real()
 
3139
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
 
3140
                name=name, append_revisions_only=append_revisions_only)
 
3141
        else:
 
3142
            # We assume the bzrdir is parameterised; it may not be.
 
3143
            result = self._custom_format.initialize(a_bzrdir, name=name,
 
3144
                append_revisions_only=append_revisions_only)
 
3145
        if (isinstance(a_bzrdir, RemoteBzrDir) and
 
3146
            not isinstance(result, RemoteBranch)):
 
3147
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
 
3148
                                  name=name)
 
3149
        return result
 
3150
 
 
3151
    def initialize(self, a_bzrdir, name=None, repository=None,
 
3152
                   append_revisions_only=None):
 
3153
        if name is None:
 
3154
            name = a_bzrdir._get_selected_branch()
 
3155
        # 1) get the network name to use.
 
3156
        if self._custom_format:
 
3157
            network_name = self._custom_format.network_name()
 
3158
        else:
 
3159
            # Select the current bzrlib default and ask for that.
 
3160
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
 
3161
            reference_format = reference_bzrdir_format.get_branch_format()
 
3162
            self._custom_format = reference_format
 
3163
            network_name = reference_format.network_name()
 
3164
        # Being asked to create on a non RemoteBzrDir:
 
3165
        if not isinstance(a_bzrdir, RemoteBzrDir):
 
3166
            return self._vfs_initialize(a_bzrdir, name=name,
 
3167
                append_revisions_only=append_revisions_only)
 
3168
        medium = a_bzrdir._client._medium
 
3169
        if medium._is_remote_before((1, 13)):
 
3170
            return self._vfs_initialize(a_bzrdir, name=name,
 
3171
                append_revisions_only=append_revisions_only)
 
3172
        # Creating on a remote bzr dir.
 
3173
        # 2) try direct creation via RPC
 
3174
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
 
3175
        if name != "":
 
3176
            # XXX JRV20100304: Support creating colocated branches
 
3177
            raise errors.NoColocatedBranchSupport(self)
 
3178
        verb = 'BzrDir.create_branch'
 
3179
        try:
 
3180
            response = a_bzrdir._call(verb, path, network_name)
 
3181
        except errors.UnknownSmartMethod:
 
3182
            # Fallback - use vfs methods
 
3183
            medium._remember_remote_is_before((1, 13))
 
3184
            return self._vfs_initialize(a_bzrdir, name=name,
 
3185
                    append_revisions_only=append_revisions_only)
 
3186
        if response[0] != 'ok':
 
3187
            raise errors.UnexpectedSmartServerResponse(response)
 
3188
        # Turn the response into a RemoteRepository object.
 
3189
        format = RemoteBranchFormat(network_name=response[1])
 
3190
        repo_format = response_tuple_to_repo_format(response[3:])
 
3191
        repo_path = response[2]
 
3192
        if repository is not None:
 
3193
            remote_repo_url = urlutils.join(a_bzrdir.user_url, repo_path)
 
3194
            url_diff = urlutils.relative_url(repository.user_url,
 
3195
                    remote_repo_url)
 
3196
            if url_diff != '.':
 
3197
                raise AssertionError(
 
3198
                    'repository.user_url %r does not match URL from server '
 
3199
                    'response (%r + %r)'
 
3200
                    % (repository.user_url, a_bzrdir.user_url, repo_path))
 
3201
            remote_repo = repository
 
3202
        else:
 
3203
            if repo_path == '':
 
3204
                repo_bzrdir = a_bzrdir
 
3205
            else:
 
3206
                repo_bzrdir = RemoteBzrDir(
 
3207
                    a_bzrdir.root_transport.clone(repo_path), a_bzrdir._format,
 
3208
                    a_bzrdir._client)
 
3209
            remote_repo = RemoteRepository(repo_bzrdir, repo_format)
 
3210
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
 
3211
            format=format, setup_stacking=False, name=name)
 
3212
        if append_revisions_only:
 
3213
            remote_branch.set_append_revisions_only(append_revisions_only)
 
3214
        # XXX: We know this is a new branch, so it must have revno 0, revid
 
3215
        # NULL_REVISION. Creating the branch locked would make this be unable
 
3216
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
 
3217
        remote_branch._last_revision_info_cache = 0, NULL_REVISION
 
3218
        return remote_branch
 
3219
 
 
3220
    def make_tags(self, branch):
 
3221
        self._ensure_real()
 
3222
        return self._custom_format.make_tags(branch)
 
3223
 
 
3224
    def supports_tags(self):
 
3225
        # Remote branches might support tags, but we won't know until we
 
3226
        # access the real remote branch.
 
3227
        self._ensure_real()
 
3228
        return self._custom_format.supports_tags()
 
3229
 
 
3230
    def supports_stacking(self):
 
3231
        self._ensure_real()
 
3232
        return self._custom_format.supports_stacking()
 
3233
 
 
3234
    def supports_set_append_revisions_only(self):
 
3235
        self._ensure_real()
 
3236
        return self._custom_format.supports_set_append_revisions_only()
 
3237
 
 
3238
    def _use_default_local_heads_to_fetch(self):
 
3239
        # If the branch format is a metadir format *and* its heads_to_fetch
 
3240
        # implementation is not overridden vs the base class, we can use the
 
3241
        # base class logic rather than use the heads_to_fetch RPC.  This is
 
3242
        # usually cheaper in terms of net round trips, as the last-revision and
 
3243
        # tags info fetched is cached and would be fetched anyway.
 
3244
        self._ensure_real()
 
3245
        if isinstance(self._custom_format, branch.BranchFormatMetadir):
 
3246
            branch_class = self._custom_format._branch_class()
 
3247
            heads_to_fetch_impl = branch_class.heads_to_fetch.im_func
 
3248
            if heads_to_fetch_impl is branch.Branch.heads_to_fetch.im_func:
 
3249
                return True
 
3250
        return False
 
3251
 
 
3252
 
 
3253
class RemoteBranchStore(_mod_config.IniFileStore):
 
3254
    """Branch store which attempts to use HPSS calls to retrieve branch store.
 
3255
 
 
3256
    Note that this is specific to bzr-based formats.
 
3257
    """
 
3258
 
 
3259
    def __init__(self, branch):
 
3260
        super(RemoteBranchStore, self).__init__()
 
3261
        self.branch = branch
 
3262
        self.id = "branch"
 
3263
        self._real_store = None
 
3264
 
 
3265
    def external_url(self):
 
3266
        return self.branch.user_url
 
3267
 
 
3268
    def _load_content(self):
 
3269
        path = self.branch._remote_path()
 
3270
        try:
 
3271
            response, handler = self.branch._call_expecting_body(
 
3272
                'Branch.get_config_file', path)
 
3273
        except errors.UnknownSmartMethod:
 
3274
            self._ensure_real()
 
3275
            return self._real_store._load_content()
 
3276
        if len(response) and response[0] != 'ok':
 
3277
            raise errors.UnexpectedSmartServerResponse(response)
 
3278
        return handler.read_body_bytes()
 
3279
 
 
3280
    def _save_content(self, content):
 
3281
        path = self.branch._remote_path()
 
3282
        try:
 
3283
            response, handler = self.branch._call_with_body_bytes_expecting_body(
 
3284
                'Branch.put_config_file', (path,
 
3285
                    self.branch._lock_token, self.branch._repo_lock_token),
 
3286
                content)
 
3287
        except errors.UnknownSmartMethod:
 
3288
            self._ensure_real()
 
3289
            return self._real_store._save_content(content)
 
3290
        handler.cancel_read_body()
 
3291
        if response != ('ok', ):
 
3292
            raise errors.UnexpectedSmartServerResponse(response)
 
3293
 
 
3294
    def _ensure_real(self):
 
3295
        self.branch._ensure_real()
 
3296
        if self._real_store is None:
 
3297
            self._real_store = _mod_config.BranchStore(self.branch)
 
3298
 
 
3299
 
 
3300
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
 
3301
    """Branch stored on a server accessed by HPSS RPC.
 
3302
 
 
3303
    At the moment most operations are mapped down to simple file operations.
 
3304
    """
 
3305
 
 
3306
    def __init__(self, remote_bzrdir, remote_repository, real_branch=None,
 
3307
        _client=None, format=None, setup_stacking=True, name=None,
 
3308
        possible_transports=None):
 
3309
        """Create a RemoteBranch instance.
 
3310
 
 
3311
        :param real_branch: An optional local implementation of the branch
 
3312
            format, usually accessing the data via the VFS.
 
3313
        :param _client: Private parameter for testing.
 
3314
        :param format: A RemoteBranchFormat object, None to create one
 
3315
            automatically. If supplied it should have a network_name already
 
3316
            supplied.
 
3317
        :param setup_stacking: If True make an RPC call to determine the
 
3318
            stacked (or not) status of the branch. If False assume the branch
 
3319
            is not stacked.
 
3320
        :param name: Colocated branch name
 
3321
        """
 
3322
        # We intentionally don't call the parent class's __init__, because it
 
3323
        # will try to assign to self.tags, which is a property in this subclass.
 
3324
        # And the parent's __init__ doesn't do much anyway.
 
3325
        self.bzrdir = remote_bzrdir
 
3326
        self.name = name
 
3327
        if _client is not None:
 
3328
            self._client = _client
 
3329
        else:
 
3330
            self._client = remote_bzrdir._client
 
3331
        self.repository = remote_repository
 
3332
        if real_branch is not None:
 
3333
            self._real_branch = real_branch
 
3334
            # Give the remote repository the matching real repo.
 
3335
            real_repo = self._real_branch.repository
 
3336
            if isinstance(real_repo, RemoteRepository):
 
3337
                real_repo._ensure_real()
 
3338
                real_repo = real_repo._real_repository
 
3339
            self.repository._set_real_repository(real_repo)
 
3340
            # Give the branch the remote repository to let fast-pathing happen.
 
3341
            self._real_branch.repository = self.repository
 
3342
        else:
 
3343
            self._real_branch = None
 
3344
        # Fill out expected attributes of branch for bzrlib API users.
 
3345
        self._clear_cached_state()
 
3346
        # TODO: deprecate self.base in favor of user_url
 
3347
        self.base = self.bzrdir.user_url
 
3348
        self._name = name
 
3349
        self._control_files = None
 
3350
        self._lock_mode = None
 
3351
        self._lock_token = None
 
3352
        self._repo_lock_token = None
 
3353
        self._lock_count = 0
 
3354
        self._leave_lock = False
 
3355
        self.conf_store = None
 
3356
        # Setup a format: note that we cannot call _ensure_real until all the
 
3357
        # attributes above are set: This code cannot be moved higher up in this
 
3358
        # function.
 
3359
        if format is None:
 
3360
            self._format = RemoteBranchFormat()
 
3361
            if real_branch is not None:
 
3362
                self._format._network_name = \
 
3363
                    self._real_branch._format.network_name()
 
3364
        else:
 
3365
            self._format = format
 
3366
        # when we do _ensure_real we may need to pass ignore_fallbacks to the
 
3367
        # branch.open_branch method.
 
3368
        self._real_ignore_fallbacks = not setup_stacking
 
3369
        if not self._format._network_name:
 
3370
            # Did not get from open_branchV2 - old server.
 
3371
            self._ensure_real()
 
3372
            self._format._network_name = \
 
3373
                self._real_branch._format.network_name()
 
3374
        self.tags = self._format.make_tags(self)
 
3375
        # The base class init is not called, so we duplicate this:
 
3376
        hooks = branch.Branch.hooks['open']
 
3377
        for hook in hooks:
 
3378
            hook(self)
 
3379
        self._is_stacked = False
 
3380
        if setup_stacking:
 
3381
            self._setup_stacking(possible_transports)
 
3382
 
 
3383
    def _setup_stacking(self, possible_transports):
 
3384
        # configure stacking into the remote repository, by reading it from
 
3385
        # the vfs branch.
 
3386
        try:
 
3387
            fallback_url = self.get_stacked_on_url()
 
3388
        except (errors.NotStacked, errors.UnstackableBranchFormat,
 
3389
            errors.UnstackableRepositoryFormat), e:
 
3390
            return
 
3391
        self._is_stacked = True
 
3392
        if possible_transports is None:
 
3393
            possible_transports = []
 
3394
        else:
 
3395
            possible_transports = list(possible_transports)
 
3396
        possible_transports.append(self.bzrdir.root_transport)
 
3397
        self._activate_fallback_location(fallback_url,
 
3398
            possible_transports=possible_transports)
 
3399
 
 
3400
    def _get_config(self):
 
3401
        return RemoteBranchConfig(self)
 
3402
 
 
3403
    def _get_config_store(self):
 
3404
        if self.conf_store is None:
 
3405
            self.conf_store =  RemoteBranchStore(self)
 
3406
        return self.conf_store
 
3407
 
 
3408
    def _get_real_transport(self):
 
3409
        # if we try vfs access, return the real branch's vfs transport
 
3410
        self._ensure_real()
 
3411
        return self._real_branch._transport
 
3412
 
 
3413
    _transport = property(_get_real_transport)
 
3414
 
 
3415
    def __str__(self):
 
3416
        return "%s(%s)" % (self.__class__.__name__, self.base)
 
3417
 
 
3418
    __repr__ = __str__
 
3419
 
 
3420
    def _ensure_real(self):
 
3421
        """Ensure that there is a _real_branch set.
 
3422
 
 
3423
        Used before calls to self._real_branch.
 
3424
        """
 
3425
        if self._real_branch is None:
 
3426
            if not vfs.vfs_enabled():
 
3427
                raise AssertionError('smart server vfs must be enabled '
 
3428
                    'to use vfs implementation')
 
3429
            self.bzrdir._ensure_real()
 
3430
            self._real_branch = self.bzrdir._real_bzrdir.open_branch(
 
3431
                ignore_fallbacks=self._real_ignore_fallbacks, name=self._name)
 
3432
            # The remote branch and the real branch shares the same store. If
 
3433
            # we don't, there will always be cases where one of the stores
 
3434
            # doesn't see an update made on the other.
 
3435
            self._real_branch.conf_store = self.conf_store
 
3436
            if self.repository._real_repository is None:
 
3437
                # Give the remote repository the matching real repo.
 
3438
                real_repo = self._real_branch.repository
 
3439
                if isinstance(real_repo, RemoteRepository):
 
3440
                    real_repo._ensure_real()
 
3441
                    real_repo = real_repo._real_repository
 
3442
                self.repository._set_real_repository(real_repo)
 
3443
            # Give the real branch the remote repository to let fast-pathing
 
3444
            # happen.
 
3445
            self._real_branch.repository = self.repository
 
3446
            if self._lock_mode == 'r':
 
3447
                self._real_branch.lock_read()
 
3448
            elif self._lock_mode == 'w':
 
3449
                self._real_branch.lock_write(token=self._lock_token)
 
3450
 
 
3451
    def _translate_error(self, err, **context):
 
3452
        self.repository._translate_error(err, branch=self, **context)
 
3453
 
 
3454
    def _clear_cached_state(self):
 
3455
        super(RemoteBranch, self)._clear_cached_state()
 
3456
        if self._real_branch is not None:
 
3457
            self._real_branch._clear_cached_state()
 
3458
 
 
3459
    def _clear_cached_state_of_remote_branch_only(self):
 
3460
        """Like _clear_cached_state, but doesn't clear the cache of
 
3461
        self._real_branch.
 
3462
 
 
3463
        This is useful when falling back to calling a method of
 
3464
        self._real_branch that changes state.  In that case the underlying
 
3465
        branch changes, so we need to invalidate this RemoteBranch's cache of
 
3466
        it.  However, there's no need to invalidate the _real_branch's cache
 
3467
        too, in fact doing so might harm performance.
 
3468
        """
 
3469
        super(RemoteBranch, self)._clear_cached_state()
 
3470
 
 
3471
    @property
 
3472
    def control_files(self):
 
3473
        # Defer actually creating RemoteBranchLockableFiles until its needed,
 
3474
        # because it triggers an _ensure_real that we otherwise might not need.
 
3475
        if self._control_files is None:
 
3476
            self._control_files = RemoteBranchLockableFiles(
 
3477
                self.bzrdir, self._client)
 
3478
        return self._control_files
 
3479
 
 
3480
    def get_physical_lock_status(self):
 
3481
        """See Branch.get_physical_lock_status()."""
 
3482
        try:
 
3483
            response = self._client.call('Branch.get_physical_lock_status',
 
3484
                self._remote_path())
 
3485
        except errors.UnknownSmartMethod:
 
3486
            self._ensure_real()
 
3487
            return self._real_branch.get_physical_lock_status()
 
3488
        if response[0] not in ('yes', 'no'):
 
3489
            raise errors.UnexpectedSmartServerResponse(response)
 
3490
        return (response[0] == 'yes')
 
3491
 
 
3492
    def get_stacked_on_url(self):
 
3493
        """Get the URL this branch is stacked against.
 
3494
 
 
3495
        :raises NotStacked: If the branch is not stacked.
 
3496
        :raises UnstackableBranchFormat: If the branch does not support
 
3497
            stacking.
 
3498
        :raises UnstackableRepositoryFormat: If the repository does not support
 
3499
            stacking.
 
3500
        """
 
3501
        try:
 
3502
            # there may not be a repository yet, so we can't use
 
3503
            # self._translate_error, so we can't use self._call either.
 
3504
            response = self._client.call('Branch.get_stacked_on_url',
 
3505
                self._remote_path())
 
3506
        except errors.ErrorFromSmartServer, err:
 
3507
            # there may not be a repository yet, so we can't call through
 
3508
            # its _translate_error
 
3509
            _translate_error(err, branch=self)
 
3510
        except errors.UnknownSmartMethod, err:
 
3511
            self._ensure_real()
 
3512
            return self._real_branch.get_stacked_on_url()
 
3513
        if response[0] != 'ok':
 
3514
            raise errors.UnexpectedSmartServerResponse(response)
 
3515
        return response[1]
 
3516
 
 
3517
    def set_stacked_on_url(self, url):
 
3518
        branch.Branch.set_stacked_on_url(self, url)
 
3519
        # We need the stacked_on_url to be visible both locally (to not query
 
3520
        # it repeatedly) and remotely (so smart verbs can get it server side)
 
3521
        # Without the following line,
 
3522
        # bzrlib.tests.per_branch.test_create_clone.TestCreateClone
 
3523
        # .test_create_clone_on_transport_stacked_hooks_get_stacked_branch
 
3524
        # fails for remote branches -- vila 2012-01-04
 
3525
        self.conf_store.save_changes()
 
3526
        if not url:
 
3527
            self._is_stacked = False
 
3528
        else:
 
3529
            self._is_stacked = True
 
3530
 
 
3531
    def _vfs_get_tags_bytes(self):
 
3532
        self._ensure_real()
 
3533
        return self._real_branch._get_tags_bytes()
 
3534
 
 
3535
    @needs_read_lock
 
3536
    def _get_tags_bytes(self):
 
3537
        if self._tags_bytes is None:
 
3538
            self._tags_bytes = self._get_tags_bytes_via_hpss()
 
3539
        return self._tags_bytes
 
3540
 
 
3541
    def _get_tags_bytes_via_hpss(self):
 
3542
        medium = self._client._medium
 
3543
        if medium._is_remote_before((1, 13)):
 
3544
            return self._vfs_get_tags_bytes()
 
3545
        try:
 
3546
            response = self._call('Branch.get_tags_bytes', self._remote_path())
 
3547
        except errors.UnknownSmartMethod:
 
3548
            medium._remember_remote_is_before((1, 13))
 
3549
            return self._vfs_get_tags_bytes()
 
3550
        return response[0]
 
3551
 
 
3552
    def _vfs_set_tags_bytes(self, bytes):
 
3553
        self._ensure_real()
 
3554
        return self._real_branch._set_tags_bytes(bytes)
 
3555
 
 
3556
    def _set_tags_bytes(self, bytes):
 
3557
        if self.is_locked():
 
3558
            self._tags_bytes = bytes
 
3559
        medium = self._client._medium
 
3560
        if medium._is_remote_before((1, 18)):
 
3561
            self._vfs_set_tags_bytes(bytes)
 
3562
            return
 
3563
        try:
 
3564
            args = (
 
3565
                self._remote_path(), self._lock_token, self._repo_lock_token)
 
3566
            response = self._call_with_body_bytes(
 
3567
                'Branch.set_tags_bytes', args, bytes)
 
3568
        except errors.UnknownSmartMethod:
 
3569
            medium._remember_remote_is_before((1, 18))
 
3570
            self._vfs_set_tags_bytes(bytes)
 
3571
 
 
3572
    def lock_read(self):
 
3573
        """Lock the branch for read operations.
 
3574
 
 
3575
        :return: A bzrlib.lock.LogicalLockResult.
 
3576
        """
 
3577
        self.repository.lock_read()
 
3578
        if not self._lock_mode:
 
3579
            self._note_lock('r')
 
3580
            self._lock_mode = 'r'
 
3581
            self._lock_count = 1
 
3582
            if self._real_branch is not None:
 
3583
                self._real_branch.lock_read()
 
3584
        else:
 
3585
            self._lock_count += 1
 
3586
        return lock.LogicalLockResult(self.unlock)
 
3587
 
 
3588
    def _remote_lock_write(self, token):
 
3589
        if token is None:
 
3590
            branch_token = repo_token = ''
 
3591
        else:
 
3592
            branch_token = token
 
3593
            repo_token = self.repository.lock_write().repository_token
 
3594
            self.repository.unlock()
 
3595
        err_context = {'token': token}
 
3596
        try:
 
3597
            response = self._call(
 
3598
                'Branch.lock_write', self._remote_path(), branch_token,
 
3599
                repo_token or '', **err_context)
 
3600
        except errors.LockContention, e:
 
3601
            # The LockContention from the server doesn't have any
 
3602
            # information about the lock_url. We re-raise LockContention
 
3603
            # with valid lock_url.
 
3604
            raise errors.LockContention('(remote lock)',
 
3605
                self.repository.base.split('.bzr/')[0])
 
3606
        if response[0] != 'ok':
 
3607
            raise errors.UnexpectedSmartServerResponse(response)
 
3608
        ok, branch_token, repo_token = response
 
3609
        return branch_token, repo_token
 
3610
 
 
3611
    def lock_write(self, token=None):
 
3612
        if not self._lock_mode:
 
3613
            self._note_lock('w')
 
3614
            # Lock the branch and repo in one remote call.
 
3615
            remote_tokens = self._remote_lock_write(token)
 
3616
            self._lock_token, self._repo_lock_token = remote_tokens
 
3617
            if not self._lock_token:
 
3618
                raise SmartProtocolError('Remote server did not return a token!')
 
3619
            # Tell the self.repository object that it is locked.
 
3620
            self.repository.lock_write(
 
3621
                self._repo_lock_token, _skip_rpc=True)
 
3622
 
 
3623
            if self._real_branch is not None:
 
3624
                self._real_branch.lock_write(token=self._lock_token)
 
3625
            if token is not None:
 
3626
                self._leave_lock = True
 
3627
            else:
 
3628
                self._leave_lock = False
 
3629
            self._lock_mode = 'w'
 
3630
            self._lock_count = 1
 
3631
        elif self._lock_mode == 'r':
 
3632
            raise errors.ReadOnlyError(self)
 
3633
        else:
 
3634
            if token is not None:
 
3635
                # A token was given to lock_write, and we're relocking, so
 
3636
                # check that the given token actually matches the one we
 
3637
                # already have.
 
3638
                if token != self._lock_token:
 
3639
                    raise errors.TokenMismatch(token, self._lock_token)
 
3640
            self._lock_count += 1
 
3641
            # Re-lock the repository too.
 
3642
            self.repository.lock_write(self._repo_lock_token)
 
3643
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
 
3644
 
 
3645
    def _unlock(self, branch_token, repo_token):
 
3646
        err_context = {'token': str((branch_token, repo_token))}
 
3647
        response = self._call(
 
3648
            'Branch.unlock', self._remote_path(), branch_token,
 
3649
            repo_token or '', **err_context)
 
3650
        if response == ('ok',):
 
3651
            return
 
3652
        raise errors.UnexpectedSmartServerResponse(response)
 
3653
 
 
3654
    @only_raises(errors.LockNotHeld, errors.LockBroken)
 
3655
    def unlock(self):
 
3656
        try:
 
3657
            self._lock_count -= 1
 
3658
            if not self._lock_count:
 
3659
                if self.conf_store is not None:
 
3660
                    self.conf_store.save_changes()
 
3661
                self._clear_cached_state()
 
3662
                mode = self._lock_mode
 
3663
                self._lock_mode = None
 
3664
                if self._real_branch is not None:
 
3665
                    if (not self._leave_lock and mode == 'w' and
 
3666
                        self._repo_lock_token):
 
3667
                        # If this RemoteBranch will remove the physical lock
 
3668
                        # for the repository, make sure the _real_branch
 
3669
                        # doesn't do it first.  (Because the _real_branch's
 
3670
                        # repository is set to be the RemoteRepository.)
 
3671
                        self._real_branch.repository.leave_lock_in_place()
 
3672
                    self._real_branch.unlock()
 
3673
                if mode != 'w':
 
3674
                    # Only write-locked branched need to make a remote method
 
3675
                    # call to perform the unlock.
 
3676
                    return
 
3677
                if not self._lock_token:
 
3678
                    raise AssertionError('Locked, but no token!')
 
3679
                branch_token = self._lock_token
 
3680
                repo_token = self._repo_lock_token
 
3681
                self._lock_token = None
 
3682
                self._repo_lock_token = None
 
3683
                if not self._leave_lock:
 
3684
                    self._unlock(branch_token, repo_token)
 
3685
        finally:
 
3686
            self.repository.unlock()
 
3687
 
 
3688
    def break_lock(self):
 
3689
        try:
 
3690
            response = self._call(
 
3691
                'Branch.break_lock', self._remote_path())
 
3692
        except errors.UnknownSmartMethod:
 
3693
            self._ensure_real()
 
3694
            return self._real_branch.break_lock()
 
3695
        if response != ('ok',):
 
3696
            raise errors.UnexpectedSmartServerResponse(response)
 
3697
 
 
3698
    def leave_lock_in_place(self):
 
3699
        if not self._lock_token:
 
3700
            raise NotImplementedError(self.leave_lock_in_place)
 
3701
        self._leave_lock = True
 
3702
 
 
3703
    def dont_leave_lock_in_place(self):
 
3704
        if not self._lock_token:
 
3705
            raise NotImplementedError(self.dont_leave_lock_in_place)
 
3706
        self._leave_lock = False
 
3707
 
 
3708
    @needs_read_lock
 
3709
    def get_rev_id(self, revno, history=None):
 
3710
        if revno == 0:
 
3711
            return _mod_revision.NULL_REVISION
 
3712
        last_revision_info = self.last_revision_info()
 
3713
        ok, result = self.repository.get_rev_id_for_revno(
 
3714
            revno, last_revision_info)
 
3715
        if ok:
 
3716
            return result
 
3717
        missing_parent = result[1]
 
3718
        # Either the revision named by the server is missing, or its parent
 
3719
        # is.  Call get_parent_map to determine which, so that we report a
 
3720
        # useful error.
 
3721
        parent_map = self.repository.get_parent_map([missing_parent])
 
3722
        if missing_parent in parent_map:
 
3723
            missing_parent = parent_map[missing_parent]
 
3724
        raise errors.RevisionNotPresent(missing_parent, self.repository)
 
3725
 
 
3726
    def _read_last_revision_info(self):
 
3727
        response = self._call('Branch.last_revision_info', self._remote_path())
 
3728
        if response[0] != 'ok':
 
3729
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
3730
        revno = int(response[1])
 
3731
        last_revision = response[2]
 
3732
        return (revno, last_revision)
 
3733
 
 
3734
    def _gen_revision_history(self):
 
3735
        """See Branch._gen_revision_history()."""
 
3736
        if self._is_stacked:
 
3737
            self._ensure_real()
 
3738
            return self._real_branch._gen_revision_history()
 
3739
        response_tuple, response_handler = self._call_expecting_body(
 
3740
            'Branch.revision_history', self._remote_path())
 
3741
        if response_tuple[0] != 'ok':
 
3742
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
3743
        result = response_handler.read_body_bytes().split('\x00')
 
3744
        if result == ['']:
 
3745
            return []
 
3746
        return result
 
3747
 
 
3748
    def _remote_path(self):
 
3749
        return self.bzrdir._path_for_remote_call(self._client)
 
3750
 
 
3751
    def _set_last_revision_descendant(self, revision_id, other_branch,
 
3752
            allow_diverged=False, allow_overwrite_descendant=False):
 
3753
        # This performs additional work to meet the hook contract; while its
 
3754
        # undesirable, we have to synthesise the revno to call the hook, and
 
3755
        # not calling the hook is worse as it means changes can't be prevented.
 
3756
        # Having calculated this though, we can't just call into
 
3757
        # set_last_revision_info as a simple call, because there is a set_rh
 
3758
        # hook that some folk may still be using.
 
3759
        old_revno, old_revid = self.last_revision_info()
 
3760
        history = self._lefthand_history(revision_id)
 
3761
        self._run_pre_change_branch_tip_hooks(len(history), revision_id)
 
3762
        err_context = {'other_branch': other_branch}
 
3763
        response = self._call('Branch.set_last_revision_ex',
 
3764
            self._remote_path(), self._lock_token, self._repo_lock_token,
 
3765
            revision_id, int(allow_diverged), int(allow_overwrite_descendant),
 
3766
            **err_context)
 
3767
        self._clear_cached_state()
 
3768
        if len(response) != 3 and response[0] != 'ok':
 
3769
            raise errors.UnexpectedSmartServerResponse(response)
 
3770
        new_revno, new_revision_id = response[1:]
 
3771
        self._last_revision_info_cache = new_revno, new_revision_id
 
3772
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
 
3773
        if self._real_branch is not None:
 
3774
            cache = new_revno, new_revision_id
 
3775
            self._real_branch._last_revision_info_cache = cache
 
3776
 
 
3777
    def _set_last_revision(self, revision_id):
 
3778
        old_revno, old_revid = self.last_revision_info()
 
3779
        # This performs additional work to meet the hook contract; while its
 
3780
        # undesirable, we have to synthesise the revno to call the hook, and
 
3781
        # not calling the hook is worse as it means changes can't be prevented.
 
3782
        # Having calculated this though, we can't just call into
 
3783
        # set_last_revision_info as a simple call, because there is a set_rh
 
3784
        # hook that some folk may still be using.
 
3785
        history = self._lefthand_history(revision_id)
 
3786
        self._run_pre_change_branch_tip_hooks(len(history), revision_id)
 
3787
        self._clear_cached_state()
 
3788
        response = self._call('Branch.set_last_revision',
 
3789
            self._remote_path(), self._lock_token, self._repo_lock_token,
 
3790
            revision_id)
 
3791
        if response != ('ok',):
 
3792
            raise errors.UnexpectedSmartServerResponse(response)
 
3793
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
 
3794
 
 
3795
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
 
3796
    @needs_write_lock
 
3797
    def set_revision_history(self, rev_history):
 
3798
        """See Branch.set_revision_history."""
 
3799
        self._set_revision_history(rev_history)
 
3800
 
 
3801
    @needs_write_lock
 
3802
    def _set_revision_history(self, rev_history):
 
3803
        # Send just the tip revision of the history; the server will generate
 
3804
        # the full history from that.  If the revision doesn't exist in this
 
3805
        # branch, NoSuchRevision will be raised.
 
3806
        if rev_history == []:
 
3807
            rev_id = 'null:'
 
3808
        else:
 
3809
            rev_id = rev_history[-1]
 
3810
        self._set_last_revision(rev_id)
 
3811
        for hook in branch.Branch.hooks['set_rh']:
 
3812
            hook(self, rev_history)
 
3813
        self._cache_revision_history(rev_history)
 
3814
 
 
3815
    def _get_parent_location(self):
 
3816
        medium = self._client._medium
 
3817
        if medium._is_remote_before((1, 13)):
 
3818
            return self._vfs_get_parent_location()
 
3819
        try:
 
3820
            response = self._call('Branch.get_parent', self._remote_path())
 
3821
        except errors.UnknownSmartMethod:
 
3822
            medium._remember_remote_is_before((1, 13))
 
3823
            return self._vfs_get_parent_location()
 
3824
        if len(response) != 1:
 
3825
            raise errors.UnexpectedSmartServerResponse(response)
 
3826
        parent_location = response[0]
 
3827
        if parent_location == '':
 
3828
            return None
 
3829
        return parent_location
 
3830
 
 
3831
    def _vfs_get_parent_location(self):
 
3832
        self._ensure_real()
 
3833
        return self._real_branch._get_parent_location()
 
3834
 
 
3835
    def _set_parent_location(self, url):
 
3836
        medium = self._client._medium
 
3837
        if medium._is_remote_before((1, 15)):
 
3838
            return self._vfs_set_parent_location(url)
 
3839
        try:
 
3840
            call_url = url or ''
 
3841
            if type(call_url) is not str:
 
3842
                raise AssertionError('url must be a str or None (%s)' % url)
 
3843
            response = self._call('Branch.set_parent_location',
 
3844
                self._remote_path(), self._lock_token, self._repo_lock_token,
 
3845
                call_url)
 
3846
        except errors.UnknownSmartMethod:
 
3847
            medium._remember_remote_is_before((1, 15))
 
3848
            return self._vfs_set_parent_location(url)
 
3849
        if response != ():
 
3850
            raise errors.UnexpectedSmartServerResponse(response)
 
3851
 
 
3852
    def _vfs_set_parent_location(self, url):
 
3853
        self._ensure_real()
 
3854
        return self._real_branch._set_parent_location(url)
 
3855
 
 
3856
    @needs_write_lock
 
3857
    def pull(self, source, overwrite=False, stop_revision=None,
 
3858
             **kwargs):
 
3859
        self._clear_cached_state_of_remote_branch_only()
 
3860
        self._ensure_real()
 
3861
        return self._real_branch.pull(
 
3862
            source, overwrite=overwrite, stop_revision=stop_revision,
 
3863
            _override_hook_target=self, **kwargs)
 
3864
 
 
3865
    @needs_read_lock
 
3866
    def push(self, target, overwrite=False, stop_revision=None, lossy=False):
 
3867
        self._ensure_real()
 
3868
        return self._real_branch.push(
 
3869
            target, overwrite=overwrite, stop_revision=stop_revision, lossy=lossy,
 
3870
            _override_hook_source_branch=self)
 
3871
 
 
3872
    def is_locked(self):
 
3873
        return self._lock_count >= 1
 
3874
 
 
3875
    @needs_read_lock
 
3876
    def revision_id_to_dotted_revno(self, revision_id):
 
3877
        """Given a revision id, return its dotted revno.
 
3878
 
 
3879
        :return: a tuple like (1,) or (400,1,3).
 
3880
        """
 
3881
        try:
 
3882
            response = self._call('Branch.revision_id_to_revno',
 
3883
                self._remote_path(), revision_id)
 
3884
        except errors.UnknownSmartMethod:
 
3885
            self._ensure_real()
 
3886
            return self._real_branch.revision_id_to_dotted_revno(revision_id)
 
3887
        if response[0] == 'ok':
 
3888
            return tuple([int(x) for x in response[1:]])
 
3889
        else:
 
3890
            raise errors.UnexpectedSmartServerResponse(response)
 
3891
 
 
3892
    @needs_read_lock
 
3893
    def revision_id_to_revno(self, revision_id):
 
3894
        """Given a revision id on the branch mainline, return its revno.
 
3895
 
 
3896
        :return: an integer
 
3897
        """
 
3898
        try:
 
3899
            response = self._call('Branch.revision_id_to_revno',
 
3900
                self._remote_path(), revision_id)
 
3901
        except errors.UnknownSmartMethod:
 
3902
            self._ensure_real()
 
3903
            return self._real_branch.revision_id_to_revno(revision_id)
 
3904
        if response[0] == 'ok':
 
3905
            if len(response) == 2:
 
3906
                return int(response[1])
 
3907
            raise NoSuchRevision(self, revision_id)
 
3908
        else:
 
3909
            raise errors.UnexpectedSmartServerResponse(response)
 
3910
 
 
3911
    @needs_write_lock
 
3912
    def set_last_revision_info(self, revno, revision_id):
 
3913
        # XXX: These should be returned by the set_last_revision_info verb
 
3914
        old_revno, old_revid = self.last_revision_info()
 
3915
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
 
3916
        if not revision_id or not isinstance(revision_id, basestring):
 
3917
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
 
3918
        try:
 
3919
            response = self._call('Branch.set_last_revision_info',
 
3920
                self._remote_path(), self._lock_token, self._repo_lock_token,
 
3921
                str(revno), revision_id)
 
3922
        except errors.UnknownSmartMethod:
 
3923
            self._ensure_real()
 
3924
            self._clear_cached_state_of_remote_branch_only()
 
3925
            self._real_branch.set_last_revision_info(revno, revision_id)
 
3926
            self._last_revision_info_cache = revno, revision_id
 
3927
            return
 
3928
        if response == ('ok',):
 
3929
            self._clear_cached_state()
 
3930
            self._last_revision_info_cache = revno, revision_id
 
3931
            self._run_post_change_branch_tip_hooks(old_revno, old_revid)
 
3932
            # Update the _real_branch's cache too.
 
3933
            if self._real_branch is not None:
 
3934
                cache = self._last_revision_info_cache
 
3935
                self._real_branch._last_revision_info_cache = cache
 
3936
        else:
 
3937
            raise errors.UnexpectedSmartServerResponse(response)
 
3938
 
 
3939
    @needs_write_lock
 
3940
    def generate_revision_history(self, revision_id, last_rev=None,
 
3941
                                  other_branch=None):
 
3942
        medium = self._client._medium
 
3943
        if not medium._is_remote_before((1, 6)):
 
3944
            # Use a smart method for 1.6 and above servers
 
3945
            try:
 
3946
                self._set_last_revision_descendant(revision_id, other_branch,
 
3947
                    allow_diverged=True, allow_overwrite_descendant=True)
 
3948
                return
 
3949
            except errors.UnknownSmartMethod:
 
3950
                medium._remember_remote_is_before((1, 6))
 
3951
        self._clear_cached_state_of_remote_branch_only()
 
3952
        self._set_revision_history(self._lefthand_history(revision_id,
 
3953
            last_rev=last_rev,other_branch=other_branch))
 
3954
 
 
3955
    def set_push_location(self, location):
 
3956
        self._set_config_location('push_location', location)
 
3957
 
 
3958
    def heads_to_fetch(self):
 
3959
        if self._format._use_default_local_heads_to_fetch():
 
3960
            # We recognise this format, and its heads-to-fetch implementation
 
3961
            # is the default one (tip + tags).  In this case it's cheaper to
 
3962
            # just use the default implementation rather than a special RPC as
 
3963
            # the tip and tags data is cached.
 
3964
            return branch.Branch.heads_to_fetch(self)
 
3965
        medium = self._client._medium
 
3966
        if medium._is_remote_before((2, 4)):
 
3967
            return self._vfs_heads_to_fetch()
 
3968
        try:
 
3969
            return self._rpc_heads_to_fetch()
 
3970
        except errors.UnknownSmartMethod:
 
3971
            medium._remember_remote_is_before((2, 4))
 
3972
            return self._vfs_heads_to_fetch()
 
3973
 
 
3974
    def _rpc_heads_to_fetch(self):
 
3975
        response = self._call('Branch.heads_to_fetch', self._remote_path())
 
3976
        if len(response) != 2:
 
3977
            raise errors.UnexpectedSmartServerResponse(response)
 
3978
        must_fetch, if_present_fetch = response
 
3979
        return set(must_fetch), set(if_present_fetch)
 
3980
 
 
3981
    def _vfs_heads_to_fetch(self):
 
3982
        self._ensure_real()
 
3983
        return self._real_branch.heads_to_fetch()
 
3984
 
 
3985
 
 
3986
class RemoteConfig(object):
 
3987
    """A Config that reads and writes from smart verbs.
 
3988
 
 
3989
    It is a low-level object that considers config data to be name/value pairs
 
3990
    that may be associated with a section. Assigning meaning to the these
 
3991
    values is done at higher levels like bzrlib.config.TreeConfig.
 
3992
    """
 
3993
 
 
3994
    def get_option(self, name, section=None, default=None):
 
3995
        """Return the value associated with a named option.
 
3996
 
 
3997
        :param name: The name of the value
 
3998
        :param section: The section the option is in (if any)
 
3999
        :param default: The value to return if the value is not set
 
4000
        :return: The value or default value
 
4001
        """
 
4002
        try:
 
4003
            configobj = self._get_configobj()
 
4004
            section_obj = None
 
4005
            if section is None:
 
4006
                section_obj = configobj
 
4007
            else:
 
4008
                try:
 
4009
                    section_obj = configobj[section]
 
4010
                except KeyError:
 
4011
                    pass
 
4012
            if section_obj is None:
 
4013
                value = default
 
4014
            else:
 
4015
                value = section_obj.get(name, default)
 
4016
        except errors.UnknownSmartMethod:
 
4017
            value = self._vfs_get_option(name, section, default)
 
4018
        for hook in _mod_config.OldConfigHooks['get']:
 
4019
            hook(self, name, value)
 
4020
        return value
 
4021
 
 
4022
    def _response_to_configobj(self, response):
 
4023
        if len(response[0]) and response[0][0] != 'ok':
 
4024
            raise errors.UnexpectedSmartServerResponse(response)
 
4025
        lines = response[1].read_body_bytes().splitlines()
 
4026
        conf = _mod_config.ConfigObj(lines, encoding='utf-8')
 
4027
        for hook in _mod_config.OldConfigHooks['load']:
 
4028
            hook(self)
 
4029
        return conf
 
4030
 
 
4031
 
 
4032
class RemoteBranchConfig(RemoteConfig):
 
4033
    """A RemoteConfig for Branches."""
 
4034
 
 
4035
    def __init__(self, branch):
 
4036
        self._branch = branch
 
4037
 
 
4038
    def _get_configobj(self):
 
4039
        path = self._branch._remote_path()
 
4040
        response = self._branch._client.call_expecting_body(
 
4041
            'Branch.get_config_file', path)
 
4042
        return self._response_to_configobj(response)
 
4043
 
 
4044
    def set_option(self, value, name, section=None):
 
4045
        """Set the value associated with a named option.
 
4046
 
 
4047
        :param value: The value to set
 
4048
        :param name: The name of the value to set
 
4049
        :param section: The section the option is in (if any)
 
4050
        """
 
4051
        medium = self._branch._client._medium
 
4052
        if medium._is_remote_before((1, 14)):
 
4053
            return self._vfs_set_option(value, name, section)
 
4054
        if isinstance(value, dict):
 
4055
            if medium._is_remote_before((2, 2)):
 
4056
                return self._vfs_set_option(value, name, section)
 
4057
            return self._set_config_option_dict(value, name, section)
 
4058
        else:
 
4059
            return self._set_config_option(value, name, section)
 
4060
 
 
4061
    def _set_config_option(self, value, name, section):
 
4062
        try:
 
4063
            path = self._branch._remote_path()
 
4064
            response = self._branch._client.call('Branch.set_config_option',
 
4065
                path, self._branch._lock_token, self._branch._repo_lock_token,
 
4066
                value.encode('utf8'), name, section or '')
 
4067
        except errors.UnknownSmartMethod:
 
4068
            medium = self._branch._client._medium
 
4069
            medium._remember_remote_is_before((1, 14))
 
4070
            return self._vfs_set_option(value, name, section)
 
4071
        if response != ():
 
4072
            raise errors.UnexpectedSmartServerResponse(response)
 
4073
 
 
4074
    def _serialize_option_dict(self, option_dict):
 
4075
        utf8_dict = {}
 
4076
        for key, value in option_dict.items():
 
4077
            if isinstance(key, unicode):
 
4078
                key = key.encode('utf8')
 
4079
            if isinstance(value, unicode):
 
4080
                value = value.encode('utf8')
 
4081
            utf8_dict[key] = value
 
4082
        return bencode.bencode(utf8_dict)
 
4083
 
 
4084
    def _set_config_option_dict(self, value, name, section):
 
4085
        try:
 
4086
            path = self._branch._remote_path()
 
4087
            serialised_dict = self._serialize_option_dict(value)
 
4088
            response = self._branch._client.call(
 
4089
                'Branch.set_config_option_dict',
 
4090
                path, self._branch._lock_token, self._branch._repo_lock_token,
 
4091
                serialised_dict, name, section or '')
 
4092
        except errors.UnknownSmartMethod:
 
4093
            medium = self._branch._client._medium
 
4094
            medium._remember_remote_is_before((2, 2))
 
4095
            return self._vfs_set_option(value, name, section)
 
4096
        if response != ():
 
4097
            raise errors.UnexpectedSmartServerResponse(response)
 
4098
 
 
4099
    def _real_object(self):
 
4100
        self._branch._ensure_real()
 
4101
        return self._branch._real_branch
 
4102
 
 
4103
    def _vfs_set_option(self, value, name, section=None):
 
4104
        return self._real_object()._get_config().set_option(
 
4105
            value, name, section)
 
4106
 
 
4107
 
 
4108
class RemoteBzrDirConfig(RemoteConfig):
 
4109
    """A RemoteConfig for BzrDirs."""
 
4110
 
 
4111
    def __init__(self, bzrdir):
 
4112
        self._bzrdir = bzrdir
 
4113
 
 
4114
    def _get_configobj(self):
 
4115
        medium = self._bzrdir._client._medium
 
4116
        verb = 'BzrDir.get_config_file'
 
4117
        if medium._is_remote_before((1, 15)):
 
4118
            raise errors.UnknownSmartMethod(verb)
 
4119
        path = self._bzrdir._path_for_remote_call(self._bzrdir._client)
 
4120
        response = self._bzrdir._call_expecting_body(
 
4121
            verb, path)
 
4122
        return self._response_to_configobj(response)
 
4123
 
 
4124
    def _vfs_get_option(self, name, section, default):
 
4125
        return self._real_object()._get_config().get_option(
 
4126
            name, section, default)
 
4127
 
 
4128
    def set_option(self, value, name, section=None):
 
4129
        """Set the value associated with a named option.
 
4130
 
 
4131
        :param value: The value to set
 
4132
        :param name: The name of the value to set
 
4133
        :param section: The section the option is in (if any)
 
4134
        """
 
4135
        return self._real_object()._get_config().set_option(
 
4136
            value, name, section)
 
4137
 
 
4138
    def _real_object(self):
 
4139
        self._bzrdir._ensure_real()
 
4140
        return self._bzrdir._real_bzrdir
 
4141
 
 
4142
 
 
4143
def _extract_tar(tar, to_dir):
 
4144
    """Extract all the contents of a tarfile object.
 
4145
 
 
4146
    A replacement for extractall, which is not present in python2.4
 
4147
    """
 
4148
    for tarinfo in tar:
 
4149
        tar.extract(tarinfo, to_dir)
 
4150
 
 
4151
 
 
4152
error_translators = registry.Registry()
 
4153
no_context_error_translators = registry.Registry()
 
4154
 
 
4155
 
 
4156
def _translate_error(err, **context):
 
4157
    """Translate an ErrorFromSmartServer into a more useful error.
 
4158
 
 
4159
    Possible context keys:
 
4160
      - branch
 
4161
      - repository
 
4162
      - bzrdir
 
4163
      - token
 
4164
      - other_branch
 
4165
      - path
 
4166
 
 
4167
    If the error from the server doesn't match a known pattern, then
 
4168
    UnknownErrorFromSmartServer is raised.
 
4169
    """
 
4170
    def find(name):
 
4171
        try:
 
4172
            return context[name]
 
4173
        except KeyError, key_err:
 
4174
            mutter('Missing key %r in context %r', key_err.args[0], context)
 
4175
            raise err
 
4176
    def get_path():
 
4177
        """Get the path from the context if present, otherwise use first error
 
4178
        arg.
 
4179
        """
 
4180
        try:
 
4181
            return context['path']
 
4182
        except KeyError, key_err:
 
4183
            try:
 
4184
                return err.error_args[0]
 
4185
            except IndexError, idx_err:
 
4186
                mutter(
 
4187
                    'Missing key %r in context %r', key_err.args[0], context)
 
4188
                raise err
 
4189
 
 
4190
    try:
 
4191
        translator = error_translators.get(err.error_verb)
 
4192
    except KeyError:
 
4193
        pass
 
4194
    else:
 
4195
        raise translator(err, find, get_path)
 
4196
    try:
 
4197
        translator = no_context_error_translators.get(err.error_verb)
 
4198
    except KeyError:
 
4199
        raise errors.UnknownErrorFromSmartServer(err)
 
4200
    else:
 
4201
        raise translator(err)
 
4202
 
 
4203
 
 
4204
error_translators.register('NoSuchRevision',
 
4205
    lambda err, find, get_path: NoSuchRevision(
 
4206
        find('branch'), err.error_args[0]))
 
4207
error_translators.register('nosuchrevision',
 
4208
    lambda err, find, get_path: NoSuchRevision(
 
4209
        find('repository'), err.error_args[0]))
 
4210
 
 
4211
def _translate_nobranch_error(err, find, get_path):
 
4212
    if len(err.error_args) >= 1:
 
4213
        extra = err.error_args[0]
 
4214
    else:
 
4215
        extra = None
 
4216
    return errors.NotBranchError(path=find('bzrdir').root_transport.base,
 
4217
        detail=extra)
 
4218
 
 
4219
error_translators.register('nobranch', _translate_nobranch_error)
 
4220
error_translators.register('norepository',
 
4221
    lambda err, find, get_path: errors.NoRepositoryPresent(
 
4222
        find('bzrdir')))
 
4223
error_translators.register('UnlockableTransport',
 
4224
    lambda err, find, get_path: errors.UnlockableTransport(
 
4225
        find('bzrdir').root_transport))
 
4226
error_translators.register('TokenMismatch',
 
4227
    lambda err, find, get_path: errors.TokenMismatch(
 
4228
        find('token'), '(remote token)'))
 
4229
error_translators.register('Diverged',
 
4230
    lambda err, find, get_path: errors.DivergedBranches(
 
4231
        find('branch'), find('other_branch')))
 
4232
error_translators.register('NotStacked',
 
4233
    lambda err, find, get_path: errors.NotStacked(branch=find('branch')))
 
4234
 
 
4235
def _translate_PermissionDenied(err, find, get_path):
 
4236
    path = get_path()
 
4237
    if len(err.error_args) >= 2:
 
4238
        extra = err.error_args[1]
 
4239
    else:
 
4240
        extra = None
 
4241
    return errors.PermissionDenied(path, extra=extra)
 
4242
 
 
4243
error_translators.register('PermissionDenied', _translate_PermissionDenied)
 
4244
error_translators.register('ReadError',
 
4245
    lambda err, find, get_path: errors.ReadError(get_path()))
 
4246
error_translators.register('NoSuchFile',
 
4247
    lambda err, find, get_path: errors.NoSuchFile(get_path()))
 
4248
error_translators.register('TokenLockingNotSupported',
 
4249
    lambda err, find, get_path: errors.TokenLockingNotSupported(
 
4250
        find('repository')))
 
4251
error_translators.register('UnsuspendableWriteGroup',
 
4252
    lambda err, find, get_path: errors.UnsuspendableWriteGroup(
 
4253
        repository=find('repository')))
 
4254
error_translators.register('UnresumableWriteGroup',
 
4255
    lambda err, find, get_path: errors.UnresumableWriteGroup(
 
4256
        repository=find('repository'), write_groups=err.error_args[0],
 
4257
        reason=err.error_args[1]))
 
4258
no_context_error_translators.register('IncompatibleRepositories',
 
4259
    lambda err: errors.IncompatibleRepositories(
 
4260
        err.error_args[0], err.error_args[1], err.error_args[2]))
 
4261
no_context_error_translators.register('LockContention',
 
4262
    lambda err: errors.LockContention('(remote lock)'))
 
4263
no_context_error_translators.register('LockFailed',
 
4264
    lambda err: errors.LockFailed(err.error_args[0], err.error_args[1]))
 
4265
no_context_error_translators.register('TipChangeRejected',
 
4266
    lambda err: errors.TipChangeRejected(err.error_args[0].decode('utf8')))
 
4267
no_context_error_translators.register('UnstackableBranchFormat',
 
4268
    lambda err: errors.UnstackableBranchFormat(*err.error_args))
 
4269
no_context_error_translators.register('UnstackableRepositoryFormat',
 
4270
    lambda err: errors.UnstackableRepositoryFormat(*err.error_args))
 
4271
no_context_error_translators.register('FileExists',
 
4272
    lambda err: errors.FileExists(err.error_args[0]))
 
4273
no_context_error_translators.register('DirectoryNotEmpty',
 
4274
    lambda err: errors.DirectoryNotEmpty(err.error_args[0]))
 
4275
 
 
4276
def _translate_short_readv_error(err):
 
4277
    args = err.error_args
 
4278
    return errors.ShortReadvError(args[0], int(args[1]), int(args[2]),
 
4279
        int(args[3]))
 
4280
 
 
4281
no_context_error_translators.register('ShortReadvError',
 
4282
    _translate_short_readv_error)
 
4283
 
 
4284
def _translate_unicode_error(err):
 
4285
        encoding = str(err.error_args[0]) # encoding must always be a string
 
4286
        val = err.error_args[1]
 
4287
        start = int(err.error_args[2])
 
4288
        end = int(err.error_args[3])
 
4289
        reason = str(err.error_args[4]) # reason must always be a string
 
4290
        if val.startswith('u:'):
 
4291
            val = val[2:].decode('utf-8')
 
4292
        elif val.startswith('s:'):
 
4293
            val = val[2:].decode('base64')
 
4294
        if err.error_verb == 'UnicodeDecodeError':
 
4295
            raise UnicodeDecodeError(encoding, val, start, end, reason)
 
4296
        elif err.error_verb == 'UnicodeEncodeError':
 
4297
            raise UnicodeEncodeError(encoding, val, start, end, reason)
 
4298
 
 
4299
no_context_error_translators.register('UnicodeEncodeError',
 
4300
    _translate_unicode_error)
 
4301
no_context_error_translators.register('UnicodeDecodeError',
 
4302
    _translate_unicode_error)
 
4303
no_context_error_translators.register('ReadOnlyError',
 
4304
    lambda err: errors.TransportNotPossible('readonly transport'))
 
4305
no_context_error_translators.register('MemoryError',
 
4306
    lambda err: errors.BzrError("remote server out of memory\n"
 
4307
        "Retry non-remotely, or contact the server admin for details."))
 
4308
no_context_error_translators.register('RevisionNotPresent',
 
4309
    lambda err: errors.RevisionNotPresent(err.error_args[0], err.error_args[1]))
 
4310
 
 
4311
no_context_error_translators.register('BzrCheckError',
 
4312
    lambda err: errors.BzrCheckError(msg=err.error_args[0]))
 
4313