/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: Jelmer Vernooij
  • Date: 2011-11-27 17:42:25 UTC
  • mto: This revision was merged to the branch mainline in revision 6311.
  • Revision ID: jelmer@samba.org-20111127174225-tspfeewl0gwxxumt
Add possible_transports in a couple more places.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
19
19
from bzrlib import (
20
20
    bencode,
21
21
    branch,
22
 
    bzrdir,
 
22
    bzrdir as _mod_bzrdir,
23
23
    config,
 
24
    controldir,
24
25
    debug,
25
26
    errors,
26
27
    graph,
27
28
    lock,
28
29
    lockdir,
29
 
    repository,
 
30
    registry,
30
31
    repository as _mod_repository,
31
 
    revision,
32
32
    revision as _mod_revision,
33
33
    static_tuple,
34
34
    symbol_versioning,
35
 
)
36
 
from bzrlib.branch import BranchReferenceFormat
37
 
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
 
35
    urlutils,
 
36
    vf_repository,
 
37
    )
 
38
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
38
39
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
39
40
from bzrlib.errors import (
40
41
    NoSuchRevision,
41
42
    SmartProtocolError,
42
43
    )
 
44
from bzrlib.i18n import gettext
 
45
from bzrlib.inventory import Inventory
43
46
from bzrlib.lockable_files import LockableFiles
44
47
from bzrlib.smart import client, vfs, repository as smart_repo
45
 
from bzrlib.revision import ensure_null, NULL_REVISION
46
 
from bzrlib.trace import mutter, note, warning
 
48
from bzrlib.smart.client import _SmartClient
 
49
from bzrlib.revision import NULL_REVISION
 
50
from bzrlib.revisiontree import InventoryRevisionTree
 
51
from bzrlib.repository import RepositoryWriteLockResult, _LazyListJoin
 
52
from bzrlib.trace import mutter, note, warning, log_exception_quietly
 
53
 
 
54
 
 
55
_DEFAULT_SEARCH_DEPTH = 100
47
56
 
48
57
 
49
58
class _RpcHelper(object):
86
95
    return format
87
96
 
88
97
 
89
 
# Note: RemoteBzrDirFormat is in bzrdir.py
90
 
 
91
 
class RemoteBzrDir(BzrDir, _RpcHelper):
 
98
# Note that RemoteBzrDirProber lives in bzrlib.bzrdir so bzrlib.remote
 
99
# does not have to be imported unless a remote format is involved.
 
100
 
 
101
class RemoteBzrDirFormat(_mod_bzrdir.BzrDirMetaFormat1):
 
102
    """Format representing bzrdirs accessed via a smart server"""
 
103
 
 
104
    supports_workingtrees = False
 
105
 
 
106
    def __init__(self):
 
107
        _mod_bzrdir.BzrDirMetaFormat1.__init__(self)
 
108
        # XXX: It's a bit ugly that the network name is here, because we'd
 
109
        # like to believe that format objects are stateless or at least
 
110
        # immutable,  However, we do at least avoid mutating the name after
 
111
        # it's returned.  See <https://bugs.launchpad.net/bzr/+bug/504102>
 
112
        self._network_name = None
 
113
 
 
114
    def __repr__(self):
 
115
        return "%s(_network_name=%r)" % (self.__class__.__name__,
 
116
            self._network_name)
 
117
 
 
118
    def get_format_description(self):
 
119
        if self._network_name:
 
120
            real_format = controldir.network_format_registry.get(self._network_name)
 
121
            return 'Remote: ' + real_format.get_format_description()
 
122
        return 'bzr remote bzrdir'
 
123
 
 
124
    def get_format_string(self):
 
125
        raise NotImplementedError(self.get_format_string)
 
126
 
 
127
    def network_name(self):
 
128
        if self._network_name:
 
129
            return self._network_name
 
130
        else:
 
131
            raise AssertionError("No network name set.")
 
132
 
 
133
    def initialize_on_transport(self, transport):
 
134
        try:
 
135
            # hand off the request to the smart server
 
136
            client_medium = transport.get_smart_medium()
 
137
        except errors.NoSmartMedium:
 
138
            # TODO: lookup the local format from a server hint.
 
139
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
140
            return local_dir_format.initialize_on_transport(transport)
 
141
        client = _SmartClient(client_medium)
 
142
        path = client.remote_path_from_transport(transport)
 
143
        try:
 
144
            response = client.call('BzrDirFormat.initialize', path)
 
145
        except errors.ErrorFromSmartServer, err:
 
146
            _translate_error(err, path=path)
 
147
        if response[0] != 'ok':
 
148
            raise errors.SmartProtocolError('unexpected response code %s' % (response,))
 
149
        format = RemoteBzrDirFormat()
 
150
        self._supply_sub_formats_to(format)
 
151
        return RemoteBzrDir(transport, format)
 
152
 
 
153
    def parse_NoneTrueFalse(self, arg):
 
154
        if not arg:
 
155
            return None
 
156
        if arg == 'False':
 
157
            return False
 
158
        if arg == 'True':
 
159
            return True
 
160
        raise AssertionError("invalid arg %r" % arg)
 
161
 
 
162
    def _serialize_NoneTrueFalse(self, arg):
 
163
        if arg is False:
 
164
            return 'False'
 
165
        if arg:
 
166
            return 'True'
 
167
        return ''
 
168
 
 
169
    def _serialize_NoneString(self, arg):
 
170
        return arg or ''
 
171
 
 
172
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
 
173
        create_prefix=False, force_new_repo=False, stacked_on=None,
 
174
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
 
175
        shared_repo=False):
 
176
        try:
 
177
            # hand off the request to the smart server
 
178
            client_medium = transport.get_smart_medium()
 
179
        except errors.NoSmartMedium:
 
180
            do_vfs = True
 
181
        else:
 
182
            # Decline to open it if the server doesn't support our required
 
183
            # version (3) so that the VFS-based transport will do it.
 
184
            if client_medium.should_probe():
 
185
                try:
 
186
                    server_version = client_medium.protocol_version()
 
187
                    if server_version != '2':
 
188
                        do_vfs = True
 
189
                    else:
 
190
                        do_vfs = False
 
191
                except errors.SmartProtocolError:
 
192
                    # Apparently there's no usable smart server there, even though
 
193
                    # the medium supports the smart protocol.
 
194
                    do_vfs = True
 
195
            else:
 
196
                do_vfs = False
 
197
        if not do_vfs:
 
198
            client = _SmartClient(client_medium)
 
199
            path = client.remote_path_from_transport(transport)
 
200
            if client_medium._is_remote_before((1, 16)):
 
201
                do_vfs = True
 
202
        if do_vfs:
 
203
            # TODO: lookup the local format from a server hint.
 
204
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
205
            self._supply_sub_formats_to(local_dir_format)
 
206
            return local_dir_format.initialize_on_transport_ex(transport,
 
207
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
208
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
209
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
210
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
211
                vfs_only=True)
 
212
        return self._initialize_on_transport_ex_rpc(client, path, transport,
 
213
            use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
214
            stack_on_pwd, repo_format_name, make_working_trees, shared_repo)
 
215
 
 
216
    def _initialize_on_transport_ex_rpc(self, client, path, transport,
 
217
        use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
218
        stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
 
219
        args = []
 
220
        args.append(self._serialize_NoneTrueFalse(use_existing_dir))
 
221
        args.append(self._serialize_NoneTrueFalse(create_prefix))
 
222
        args.append(self._serialize_NoneTrueFalse(force_new_repo))
 
223
        args.append(self._serialize_NoneString(stacked_on))
 
224
        # stack_on_pwd is often/usually our transport
 
225
        if stack_on_pwd:
 
226
            try:
 
227
                stack_on_pwd = transport.relpath(stack_on_pwd)
 
228
                if not stack_on_pwd:
 
229
                    stack_on_pwd = '.'
 
230
            except errors.PathNotChild:
 
231
                pass
 
232
        args.append(self._serialize_NoneString(stack_on_pwd))
 
233
        args.append(self._serialize_NoneString(repo_format_name))
 
234
        args.append(self._serialize_NoneTrueFalse(make_working_trees))
 
235
        args.append(self._serialize_NoneTrueFalse(shared_repo))
 
236
        request_network_name = self._network_name or \
 
237
            _mod_bzrdir.BzrDirFormat.get_default_format().network_name()
 
238
        try:
 
239
            response = client.call('BzrDirFormat.initialize_ex_1.16',
 
240
                request_network_name, path, *args)
 
241
        except errors.UnknownSmartMethod:
 
242
            client._medium._remember_remote_is_before((1,16))
 
243
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
244
            self._supply_sub_formats_to(local_dir_format)
 
245
            return local_dir_format.initialize_on_transport_ex(transport,
 
246
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
247
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
248
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
249
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
250
                vfs_only=True)
 
251
        except errors.ErrorFromSmartServer, err:
 
252
            _translate_error(err, path=path)
 
253
        repo_path = response[0]
 
254
        bzrdir_name = response[6]
 
255
        require_stacking = response[7]
 
256
        require_stacking = self.parse_NoneTrueFalse(require_stacking)
 
257
        format = RemoteBzrDirFormat()
 
258
        format._network_name = bzrdir_name
 
259
        self._supply_sub_formats_to(format)
 
260
        bzrdir = RemoteBzrDir(transport, format, _client=client)
 
261
        if repo_path:
 
262
            repo_format = response_tuple_to_repo_format(response[1:])
 
263
            if repo_path == '.':
 
264
                repo_path = ''
 
265
            if repo_path:
 
266
                repo_bzrdir_format = RemoteBzrDirFormat()
 
267
                repo_bzrdir_format._network_name = response[5]
 
268
                repo_bzr = RemoteBzrDir(transport.clone(repo_path),
 
269
                    repo_bzrdir_format)
 
270
            else:
 
271
                repo_bzr = bzrdir
 
272
            final_stack = response[8] or None
 
273
            final_stack_pwd = response[9] or None
 
274
            if final_stack_pwd:
 
275
                final_stack_pwd = urlutils.join(
 
276
                    transport.base, final_stack_pwd)
 
277
            remote_repo = RemoteRepository(repo_bzr, repo_format)
 
278
            if len(response) > 10:
 
279
                # Updated server verb that locks remotely.
 
280
                repo_lock_token = response[10] or None
 
281
                remote_repo.lock_write(repo_lock_token, _skip_rpc=True)
 
282
                if repo_lock_token:
 
283
                    remote_repo.dont_leave_lock_in_place()
 
284
            else:
 
285
                remote_repo.lock_write()
 
286
            policy = _mod_bzrdir.UseExistingRepository(remote_repo, final_stack,
 
287
                final_stack_pwd, require_stacking)
 
288
            policy.acquire_repository()
 
289
        else:
 
290
            remote_repo = None
 
291
            policy = None
 
292
        bzrdir._format.set_branch_format(self.get_branch_format())
 
293
        if require_stacking:
 
294
            # The repo has already been created, but we need to make sure that
 
295
            # we'll make a stackable branch.
 
296
            bzrdir._format.require_stacking(_skip_repo=True)
 
297
        return remote_repo, bzrdir, require_stacking, policy
 
298
 
 
299
    def _open(self, transport):
 
300
        return RemoteBzrDir(transport, self)
 
301
 
 
302
    def __eq__(self, other):
 
303
        if not isinstance(other, RemoteBzrDirFormat):
 
304
            return False
 
305
        return self.get_format_description() == other.get_format_description()
 
306
 
 
307
    def __return_repository_format(self):
 
308
        # Always return a RemoteRepositoryFormat object, but if a specific bzr
 
309
        # repository format has been asked for, tell the RemoteRepositoryFormat
 
310
        # that it should use that for init() etc.
 
311
        result = RemoteRepositoryFormat()
 
312
        custom_format = getattr(self, '_repository_format', None)
 
313
        if custom_format:
 
314
            if isinstance(custom_format, RemoteRepositoryFormat):
 
315
                return custom_format
 
316
            else:
 
317
                # We will use the custom format to create repositories over the
 
318
                # wire; expose its details like rich_root_data for code to
 
319
                # query
 
320
                result._custom_format = custom_format
 
321
        return result
 
322
 
 
323
    def get_branch_format(self):
 
324
        result = _mod_bzrdir.BzrDirMetaFormat1.get_branch_format(self)
 
325
        if not isinstance(result, RemoteBranchFormat):
 
326
            new_result = RemoteBranchFormat()
 
327
            new_result._custom_format = result
 
328
            # cache the result
 
329
            self.set_branch_format(new_result)
 
330
            result = new_result
 
331
        return result
 
332
 
 
333
    repository_format = property(__return_repository_format,
 
334
        _mod_bzrdir.BzrDirMetaFormat1._set_repository_format) #.im_func)
 
335
 
 
336
 
 
337
class RemoteControlStore(config.IniFileStore):
 
338
    """Control store which attempts to use HPSS calls to retrieve control store.
 
339
 
 
340
    Note that this is specific to bzr-based formats.
 
341
    """
 
342
 
 
343
    def __init__(self, bzrdir):
 
344
        super(RemoteControlStore, self).__init__()
 
345
        self.bzrdir = bzrdir
 
346
        self._real_store = None
 
347
 
 
348
    def lock_write(self, token=None):
 
349
        self._ensure_real()
 
350
        return self._real_store.lock_write(token)
 
351
 
 
352
    def unlock(self):
 
353
        self._ensure_real()
 
354
        return self._real_store.unlock()
 
355
 
 
356
    @needs_write_lock
 
357
    def save(self):
 
358
        # We need to be able to override the undecorated implementation
 
359
        self.save_without_locking()
 
360
 
 
361
    def save_without_locking(self):
 
362
        super(RemoteControlStore, self).save()
 
363
 
 
364
    def _ensure_real(self):
 
365
        self.bzrdir._ensure_real()
 
366
        if self._real_store is None:
 
367
            self._real_store = config.ControlStore(self.bzrdir)
 
368
 
 
369
    def external_url(self):
 
370
        return self.bzrdir.user_url
 
371
 
 
372
    def _load_content(self):
 
373
        medium = self.bzrdir._client._medium
 
374
        path = self.bzrdir._path_for_remote_call(self.bzrdir._client)
 
375
        try:
 
376
            response, handler = self.bzrdir._call_expecting_body(
 
377
                'BzrDir.get_config_file', path)
 
378
        except errors.UnknownSmartMethod:
 
379
            self._ensure_real()
 
380
            return self._real_store._load_content()
 
381
        if len(response) and response[0] != 'ok':
 
382
            raise errors.UnexpectedSmartServerResponse(response)
 
383
        return handler.read_body_bytes()
 
384
 
 
385
    def _save_content(self, content):
 
386
        # FIXME JRV 2011-11-22: Ideally this should use a
 
387
        # HPSS call too, but at the moment it is not possible
 
388
        # to write lock control directories.
 
389
        self._ensure_real()
 
390
        return self._real_store._save_content(content)
 
391
 
 
392
 
 
393
class RemoteBzrDir(_mod_bzrdir.BzrDir, _RpcHelper):
92
394
    """Control directory on a remote server, accessed via bzr:// or similar."""
93
395
 
94
396
    def __init__(self, transport, format, _client=None, _force_probe=False):
97
399
        :param _client: Private parameter for testing. Disables probing and the
98
400
            use of a real bzrdir.
99
401
        """
100
 
        BzrDir.__init__(self, transport, format)
 
402
        _mod_bzrdir.BzrDir.__init__(self, transport, format)
101
403
        # this object holds a delegated bzrdir that uses file-level operations
102
404
        # to talk to the other side
103
405
        self._real_bzrdir = None
163
465
                import traceback
164
466
                warning('VFS BzrDir access triggered\n%s',
165
467
                    ''.join(traceback.format_stack()))
166
 
            self._real_bzrdir = BzrDir.open_from_transport(
 
468
            self._real_bzrdir = _mod_bzrdir.BzrDir.open_from_transport(
167
469
                self.root_transport, _server_formats=False)
168
470
            self._format._network_name = \
169
471
                self._real_bzrdir._format.network_name()
175
477
        # Prevent aliasing problems in the next_open_branch_result cache.
176
478
        # See create_branch for rationale.
177
479
        self._next_open_branch_result = None
178
 
        return BzrDir.break_lock(self)
 
480
        return _mod_bzrdir.BzrDir.break_lock(self)
179
481
 
180
482
    def _vfs_cloning_metadir(self, require_stacking=False):
181
483
        self._ensure_real()
212
514
        if len(branch_info) != 2:
213
515
            raise errors.UnexpectedSmartServerResponse(response)
214
516
        branch_ref, branch_name = branch_info
215
 
        format = bzrdir.network_format_registry.get(control_name)
 
517
        format = controldir.network_format_registry.get(control_name)
216
518
        if repo_name:
217
 
            format.repository_format = repository.network_format_registry.get(
 
519
            format.repository_format = _mod_repository.network_format_registry.get(
218
520
                repo_name)
219
521
        if branch_ref == 'ref':
220
522
            # XXX: we need possible_transports here to avoid reopening the
221
523
            # connection to the referenced location
222
 
            ref_bzrdir = BzrDir.open(branch_name)
 
524
            ref_bzrdir = _mod_bzrdir.BzrDir.open(branch_name)
223
525
            branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
224
526
            format.set_branch_format(branch_format)
225
527
        elif branch_ref == 'branch':
241
543
 
242
544
    def destroy_repository(self):
243
545
        """See BzrDir.destroy_repository"""
244
 
        self._ensure_real()
245
 
        self._real_bzrdir.destroy_repository()
 
546
        path = self._path_for_remote_call(self._client)
 
547
        try:
 
548
            response = self._call('BzrDir.destroy_repository', path)
 
549
        except errors.UnknownSmartMethod:
 
550
            self._ensure_real()
 
551
            self._real_bzrdir.destroy_repository()
 
552
            return
 
553
        if response[0] != 'ok':
 
554
            raise SmartProtocolError('unexpected response code %s' % (response,))
246
555
 
247
 
    def create_branch(self, name=None):
 
556
    def create_branch(self, name=None, repository=None,
 
557
                      append_revisions_only=None):
248
558
        # as per meta1 formats - just delegate to the format object which may
249
559
        # be parameterised.
250
560
        real_branch = self._format.get_branch_format().initialize(self,
251
 
            name=name)
 
561
            name=name, repository=repository,
 
562
            append_revisions_only=append_revisions_only)
252
563
        if not isinstance(real_branch, RemoteBranch):
253
 
            result = RemoteBranch(self, self.find_repository(), real_branch,
254
 
                                  name=name)
 
564
            if not isinstance(repository, RemoteRepository):
 
565
                raise AssertionError(
 
566
                    'need a RemoteRepository to use with RemoteBranch, got %r'
 
567
                    % (repository,))
 
568
            result = RemoteBranch(self, repository, real_branch, name=name)
255
569
        else:
256
570
            result = real_branch
257
571
        # BzrDir.clone_on_transport() uses the result of create_branch but does
265
579
 
266
580
    def destroy_branch(self, name=None):
267
581
        """See BzrDir.destroy_branch"""
268
 
        self._ensure_real()
269
 
        self._real_bzrdir.destroy_branch(name=name)
 
582
        path = self._path_for_remote_call(self._client)
 
583
        try:
 
584
            if name is not None:
 
585
                args = (name, )
 
586
            else:
 
587
                args = ()
 
588
            response = self._call('BzrDir.destroy_branch', path, *args)
 
589
        except errors.UnknownSmartMethod:
 
590
            self._ensure_real()
 
591
            self._real_bzrdir.destroy_branch(name=name)
 
592
            self._next_open_branch_result = None
 
593
            return
270
594
        self._next_open_branch_result = None
 
595
        if response[0] != 'ok':
 
596
            raise SmartProtocolError('unexpected response code %s' % (response,))
271
597
 
272
 
    def create_workingtree(self, revision_id=None, from_branch=None):
 
598
    def create_workingtree(self, revision_id=None, from_branch=None,
 
599
        accelerator_tree=None, hardlink=False):
273
600
        raise errors.NotLocalUrl(self.transport.base)
274
601
 
275
 
    def find_branch_format(self):
 
602
    def find_branch_format(self, name=None):
276
603
        """Find the branch 'format' for this bzrdir.
277
604
 
278
605
        This might be a synthetic object for e.g. RemoteBranch and SVN.
279
606
        """
280
 
        b = self.open_branch()
 
607
        b = self.open_branch(name=name)
281
608
        return b._format
282
609
 
283
 
    def get_branch_reference(self):
 
610
    def get_branch_reference(self, name=None):
284
611
        """See BzrDir.get_branch_reference()."""
 
612
        if name is not None:
 
613
            # XXX JRV20100304: Support opening colocated branches
 
614
            raise errors.NoColocatedBranchSupport(self)
285
615
        response = self._get_branch_reference()
286
616
        if response[0] == 'ref':
287
617
            return response[1]
318
648
            raise errors.UnexpectedSmartServerResponse(response)
319
649
        return response
320
650
 
321
 
    def _get_tree_branch(self):
 
651
    def _get_tree_branch(self, name=None):
322
652
        """See BzrDir._get_tree_branch()."""
323
 
        return None, self.open_branch()
 
653
        return None, self.open_branch(name=name)
324
654
 
325
655
    def open_branch(self, name=None, unsupported=False,
326
 
                    ignore_fallbacks=False):
 
656
                    ignore_fallbacks=False, possible_transports=None):
327
657
        if unsupported:
328
658
            raise NotImplementedError('unsupported flag support not implemented yet.')
329
659
        if self._next_open_branch_result is not None:
336
666
            # a branch reference, use the existing BranchReference logic.
337
667
            format = BranchReferenceFormat()
338
668
            return format.open(self, name=name, _found=True,
339
 
                location=response[1], ignore_fallbacks=ignore_fallbacks)
 
669
                location=response[1], ignore_fallbacks=ignore_fallbacks,
 
670
                possible_transports=possible_transports)
340
671
        branch_format_name = response[1]
341
672
        if not branch_format_name:
342
673
            branch_format_name = None
411
742
 
412
743
    def has_workingtree(self):
413
744
        if self._has_working_tree is None:
414
 
            self._ensure_real()
415
 
            self._has_working_tree = self._real_bzrdir.has_workingtree()
 
745
            path = self._path_for_remote_call(self._client)
 
746
            try:
 
747
                response = self._call('BzrDir.has_workingtree', path)
 
748
            except errors.UnknownSmartMethod:
 
749
                self._ensure_real()
 
750
                self._has_working_tree = self._real_bzrdir.has_workingtree()
 
751
            else:
 
752
                if response[0] not in ('yes', 'no'):
 
753
                    raise SmartProtocolError('unexpected response code %s' % (response,))
 
754
                self._has_working_tree = (response[0] == 'yes')
416
755
        return self._has_working_tree
417
756
 
418
757
    def open_workingtree(self, recommend_upgrade=True):
423
762
 
424
763
    def _path_for_remote_call(self, client):
425
764
        """Return the path to be used for this bzrdir in a remote call."""
426
 
        return client.remote_path_from_transport(self.root_transport)
 
765
        return urlutils.split_segment_parameters_raw(
 
766
            client.remote_path_from_transport(self.root_transport))[0]
427
767
 
428
768
    def get_branch_transport(self, branch_format, name=None):
429
769
        self._ensure_real()
441
781
        """Upgrading of remote bzrdirs is not supported yet."""
442
782
        return False
443
783
 
444
 
    def needs_format_conversion(self, format=None):
 
784
    def needs_format_conversion(self, format):
445
785
        """Upgrading of remote bzrdirs is not supported yet."""
446
 
        if format is None:
447
 
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
448
 
                % 'needs_format_conversion(format=None)')
449
786
        return False
450
787
 
451
 
    def clone(self, url, revision_id=None, force_new_repo=False,
452
 
              preserve_stacking=False):
453
 
        self._ensure_real()
454
 
        return self._real_bzrdir.clone(url, revision_id=revision_id,
455
 
            force_new_repo=force_new_repo, preserve_stacking=preserve_stacking)
456
 
 
457
788
    def _get_config(self):
458
789
        return RemoteBzrDirConfig(self)
459
790
 
460
 
 
461
 
class RemoteRepositoryFormat(repository.RepositoryFormat):
 
791
    def _get_config_store(self):
 
792
        return RemoteControlStore(self)
 
793
 
 
794
 
 
795
class RemoteRepositoryFormat(vf_repository.VersionedFileRepositoryFormat):
462
796
    """Format for repositories accessed over a _SmartClient.
463
797
 
464
798
    Instances of this repository are represented by RemoteRepository
479
813
    """
480
814
 
481
815
    _matchingbzrdir = RemoteBzrDirFormat()
 
816
    supports_full_versioned_files = True
 
817
    supports_leaving_lock = True
482
818
 
483
819
    def __init__(self):
484
 
        repository.RepositoryFormat.__init__(self)
 
820
        _mod_repository.RepositoryFormat.__init__(self)
485
821
        self._custom_format = None
486
822
        self._network_name = None
487
823
        self._creating_bzrdir = None
 
824
        self._revision_graph_can_have_wrong_parents = None
488
825
        self._supports_chks = None
489
826
        self._supports_external_lookups = None
490
827
        self._supports_tree_reference = None
 
828
        self._supports_funky_characters = None
 
829
        self._supports_nesting_repositories = None
491
830
        self._rich_root_data = None
492
831
 
493
832
    def __repr__(self):
522
861
        return self._supports_external_lookups
523
862
 
524
863
    @property
 
864
    def supports_funky_characters(self):
 
865
        if self._supports_funky_characters is None:
 
866
            self._ensure_real()
 
867
            self._supports_funky_characters = \
 
868
                self._custom_format.supports_funky_characters
 
869
        return self._supports_funky_characters
 
870
 
 
871
    @property
 
872
    def supports_nesting_repositories(self):
 
873
        if self._supports_nesting_repositories is None:
 
874
            self._ensure_real()
 
875
            self._supports_nesting_repositories = \
 
876
                self._custom_format.supports_nesting_repositories
 
877
        return self._supports_nesting_repositories
 
878
 
 
879
    @property
525
880
    def supports_tree_reference(self):
526
881
        if self._supports_tree_reference is None:
527
882
            self._ensure_real()
529
884
                self._custom_format.supports_tree_reference
530
885
        return self._supports_tree_reference
531
886
 
 
887
    @property
 
888
    def revision_graph_can_have_wrong_parents(self):
 
889
        if self._revision_graph_can_have_wrong_parents is None:
 
890
            self._ensure_real()
 
891
            self._revision_graph_can_have_wrong_parents = \
 
892
                self._custom_format.revision_graph_can_have_wrong_parents
 
893
        return self._revision_graph_can_have_wrong_parents
 
894
 
532
895
    def _vfs_initialize(self, a_bzrdir, shared):
533
896
        """Helper for common code in initialize."""
534
897
        if self._custom_format:
569
932
            network_name = self._network_name
570
933
        else:
571
934
            # Select the current bzrlib default and ask for that.
572
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
935
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
573
936
            reference_format = reference_bzrdir_format.repository_format
574
937
            network_name = reference_format.network_name()
575
938
        # 2) try direct creation via RPC
601
964
 
602
965
    def _ensure_real(self):
603
966
        if self._custom_format is None:
604
 
            self._custom_format = repository.network_format_registry.get(
 
967
            self._custom_format = _mod_repository.network_format_registry.get(
605
968
                self._network_name)
606
969
 
607
970
    @property
643
1006
        return self._custom_format._serializer
644
1007
 
645
1008
 
646
 
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
647
 
    bzrdir.ControlComponent):
 
1009
class RemoteRepository(_mod_repository.Repository, _RpcHelper,
 
1010
        lock._RelockDebugMixin):
648
1011
    """Repository accessed over rpc.
649
1012
 
650
1013
    For the moment most operations are performed using local transport-backed
674
1037
        self._format = format
675
1038
        self._lock_mode = None
676
1039
        self._lock_token = None
 
1040
        self._write_group_tokens = None
677
1041
        self._lock_count = 0
678
1042
        self._leave_lock = False
679
1043
        # Cache of revision parents; misses are cached during read locks, and
703
1067
        # transport, but I'm not sure it's worth making this method
704
1068
        # optional -- mbp 2010-04-21
705
1069
        return self.bzrdir.get_repository_transport(None)
706
 
        
 
1070
 
707
1071
    def __str__(self):
708
1072
        return "%s(%s)" % (self.__class__.__name__, self.base)
709
1073
 
719
1083
 
720
1084
        :param suppress_errors: see Repository.abort_write_group.
721
1085
        """
722
 
        self._ensure_real()
723
 
        return self._real_repository.abort_write_group(
724
 
            suppress_errors=suppress_errors)
 
1086
        if self._real_repository:
 
1087
            self._ensure_real()
 
1088
            return self._real_repository.abort_write_group(
 
1089
                suppress_errors=suppress_errors)
 
1090
        if not self.is_in_write_group():
 
1091
            if suppress_errors:
 
1092
                mutter('(suppressed) not in write group')
 
1093
                return
 
1094
            raise errors.BzrError("not in write group")
 
1095
        path = self.bzrdir._path_for_remote_call(self._client)
 
1096
        try:
 
1097
            response = self._call('Repository.abort_write_group', path,
 
1098
                self._lock_token, self._write_group_tokens)
 
1099
        except Exception, exc:
 
1100
            self._write_group = None
 
1101
            if not suppress_errors:
 
1102
                raise
 
1103
            mutter('abort_write_group failed')
 
1104
            log_exception_quietly()
 
1105
            note(gettext('bzr: ERROR (ignored): %s'), exc)
 
1106
        else:
 
1107
            if response != ('ok', ):
 
1108
                raise errors.UnexpectedSmartServerResponse(response)
 
1109
            self._write_group_tokens = None
725
1110
 
726
1111
    @property
727
1112
    def chk_bytes(self):
741
1126
        for older plugins that don't use e.g. the CommitBuilder
742
1127
        facility.
743
1128
        """
744
 
        self._ensure_real()
745
 
        return self._real_repository.commit_write_group()
 
1129
        if self._real_repository:
 
1130
            self._ensure_real()
 
1131
            return self._real_repository.commit_write_group()
 
1132
        if not self.is_in_write_group():
 
1133
            raise errors.BzrError("not in write group")
 
1134
        path = self.bzrdir._path_for_remote_call(self._client)
 
1135
        response = self._call('Repository.commit_write_group', path,
 
1136
            self._lock_token, self._write_group_tokens)
 
1137
        if response != ('ok', ):
 
1138
            raise errors.UnexpectedSmartServerResponse(response)
 
1139
        self._write_group_tokens = None
746
1140
 
747
1141
    def resume_write_group(self, tokens):
748
 
        self._ensure_real()
749
 
        return self._real_repository.resume_write_group(tokens)
 
1142
        if self._real_repository:
 
1143
            return self._real_repository.resume_write_group(tokens)
 
1144
        path = self.bzrdir._path_for_remote_call(self._client)
 
1145
        try:
 
1146
            response = self._call('Repository.check_write_group', path,
 
1147
               self._lock_token, tokens)
 
1148
        except errors.UnknownSmartMethod:
 
1149
            self._ensure_real()
 
1150
            return self._real_repository.resume_write_group(tokens)
 
1151
        if response != ('ok', ):
 
1152
            raise errors.UnexpectedSmartServerResponse(response)
 
1153
        self._write_group_tokens = tokens
750
1154
 
751
1155
    def suspend_write_group(self):
752
 
        self._ensure_real()
753
 
        return self._real_repository.suspend_write_group()
 
1156
        if self._real_repository:
 
1157
            return self._real_repository.suspend_write_group()
 
1158
        ret = self._write_group_tokens or []
 
1159
        self._write_group_tokens = None
 
1160
        return ret
754
1161
 
755
1162
    def get_missing_parent_inventories(self, check_for_missing_texts=True):
756
1163
        self._ensure_real()
817
1224
    def find_text_key_references(self):
818
1225
        """Find the text key references within the repository.
819
1226
 
820
 
        :return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
821
 
        revision_ids. Each altered file-ids has the exact revision_ids that
822
 
        altered it listed explicitly.
823
1227
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
824
1228
            to whether they were referred to by the inventory of the
825
1229
            revision_id that they contain. The inventory texts from all present
843
1247
        """Private method for using with old (< 1.2) servers to fallback."""
844
1248
        if revision_id is None:
845
1249
            revision_id = ''
846
 
        elif revision.is_null(revision_id):
 
1250
        elif _mod_revision.is_null(revision_id):
847
1251
            return {}
848
1252
 
849
1253
        path = self.bzrdir._path_for_remote_call(self._client)
873
1277
        return RemoteStreamSource(self, to_format)
874
1278
 
875
1279
    @needs_read_lock
 
1280
    def get_file_graph(self):
 
1281
        return graph.Graph(self.texts)
 
1282
 
 
1283
    @needs_read_lock
876
1284
    def has_revision(self, revision_id):
877
1285
        """True if this repository has a copy of the revision."""
878
1286
        # Copy of bzrlib.repository.Repository.has_revision
895
1303
    def _has_same_fallbacks(self, other_repo):
896
1304
        """Returns true if the repositories have the same fallbacks."""
897
1305
        # XXX: copied from Repository; it should be unified into a base class
898
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
 
1306
        # <https://bugs.launchpad.net/bzr/+bug/401622>
899
1307
        my_fb = self._fallback_repositories
900
1308
        other_fb = other_repo._fallback_repositories
901
1309
        if len(my_fb) != len(other_fb):
930
1338
        """See Repository.gather_stats()."""
931
1339
        path = self.bzrdir._path_for_remote_call(self._client)
932
1340
        # revid can be None to indicate no revisions, not just NULL_REVISION
933
 
        if revid is None or revision.is_null(revid):
 
1341
        if revid is None or _mod_revision.is_null(revid):
934
1342
            fmt_revid = ''
935
1343
        else:
936
1344
            fmt_revid = revid
965
1373
 
966
1374
    def get_physical_lock_status(self):
967
1375
        """See Repository.get_physical_lock_status()."""
968
 
        # should be an API call to the server.
969
 
        self._ensure_real()
970
 
        return self._real_repository.get_physical_lock_status()
 
1376
        path = self.bzrdir._path_for_remote_call(self._client)
 
1377
        try:
 
1378
            response = self._call('Repository.get_physical_lock_status', path)
 
1379
        except errors.UnknownSmartMethod:
 
1380
            self._ensure_real()
 
1381
            return self._real_repository.get_physical_lock_status()
 
1382
        if response[0] not in ('yes', 'no'):
 
1383
            raise errors.UnexpectedSmartServerResponse(response)
 
1384
        return (response[0] == 'yes')
971
1385
 
972
1386
    def is_in_write_group(self):
973
1387
        """Return True if there is an open write group.
974
1388
 
975
1389
        write groups are only applicable locally for the smart server..
976
1390
        """
 
1391
        if self._write_group_tokens is not None:
 
1392
            return True
977
1393
        if self._real_repository:
978
1394
            return self._real_repository.is_in_write_group()
979
1395
 
997
1413
        pass
998
1414
 
999
1415
    def lock_read(self):
 
1416
        """Lock the repository for read operations.
 
1417
 
 
1418
        :return: A bzrlib.lock.LogicalLockResult.
 
1419
        """
1000
1420
        # wrong eventually - want a local lock cache context
1001
1421
        if not self._lock_mode:
1002
1422
            self._note_lock('r')
1009
1429
                repo.lock_read()
1010
1430
        else:
1011
1431
            self._lock_count += 1
 
1432
        return lock.LogicalLockResult(self.unlock)
1012
1433
 
1013
1434
    def _remote_lock_write(self, token):
1014
1435
        path = self.bzrdir._path_for_remote_call(self._client)
1054
1475
            raise errors.ReadOnlyError(self)
1055
1476
        else:
1056
1477
            self._lock_count += 1
1057
 
        return self._lock_token or None
 
1478
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
1058
1479
 
1059
1480
    def leave_lock_in_place(self):
1060
1481
        if not self._lock_token:
1109
1530
            self._real_repository.lock_write(self._lock_token)
1110
1531
        elif self._lock_mode == 'r':
1111
1532
            self._real_repository.lock_read()
 
1533
        if self._write_group_tokens is not None:
 
1534
            # if we are already in a write group, resume it
 
1535
            self._real_repository.resume_write_group(self._write_group_tokens)
 
1536
            self._write_group_tokens = None
1112
1537
 
1113
1538
    def start_write_group(self):
1114
1539
        """Start a write group on the decorated repository.
1118
1543
        for older plugins that don't use e.g. the CommitBuilder
1119
1544
        facility.
1120
1545
        """
1121
 
        self._ensure_real()
1122
 
        return self._real_repository.start_write_group()
 
1546
        if self._real_repository:
 
1547
            self._ensure_real()
 
1548
            return self._real_repository.start_write_group()
 
1549
        if not self.is_write_locked():
 
1550
            raise errors.NotWriteLocked(self)
 
1551
        if self._write_group_tokens is not None:
 
1552
            raise errors.BzrError('already in a write group')
 
1553
        path = self.bzrdir._path_for_remote_call(self._client)
 
1554
        try:
 
1555
            response = self._call('Repository.start_write_group', path,
 
1556
                self._lock_token)
 
1557
        except (errors.UnknownSmartMethod, errors.UnsuspendableWriteGroup):
 
1558
            self._ensure_real()
 
1559
            return self._real_repository.start_write_group()
 
1560
        if response[0] != 'ok':
 
1561
            raise errors.UnexpectedSmartServerResponse(response)
 
1562
        self._write_group_tokens = response[1]
1123
1563
 
1124
1564
    def _unlock(self, token):
1125
1565
        path = self.bzrdir._path_for_remote_call(self._client)
1152
1592
            # This is just to let the _real_repository stay up to date.
1153
1593
            if self._real_repository is not None:
1154
1594
                self._real_repository.unlock()
 
1595
            elif self._write_group_tokens is not None:
 
1596
                self.abort_write_group()
1155
1597
        finally:
1156
1598
            # The rpc-level lock should be released even if there was a
1157
1599
            # problem releasing the vfs-based lock.
1169
1611
 
1170
1612
    def break_lock(self):
1171
1613
        # should hand off to the network
1172
 
        self._ensure_real()
1173
 
        return self._real_repository.break_lock()
 
1614
        path = self.bzrdir._path_for_remote_call(self._client)
 
1615
        try:
 
1616
            response = self._call("Repository.break_lock", path)
 
1617
        except errors.UnknownSmartMethod:
 
1618
            self._ensure_real()
 
1619
            return self._real_repository.break_lock()
 
1620
        if response != ('ok',):
 
1621
            raise errors.UnexpectedSmartServerResponse(response)
1174
1622
 
1175
1623
    def _get_tarball(self, compression):
1176
1624
        """Return a TemporaryFile containing a repository tarball.
1194
1642
            return t
1195
1643
        raise errors.UnexpectedSmartServerResponse(response)
1196
1644
 
 
1645
    @needs_read_lock
1197
1646
    def sprout(self, to_bzrdir, revision_id=None):
1198
 
        # TODO: Option to control what format is created?
1199
 
        self._ensure_real()
1200
 
        dest_repo = self._real_repository._format.initialize(to_bzrdir,
1201
 
                                                             shared=False)
 
1647
        """Create a descendent repository for new development.
 
1648
 
 
1649
        Unlike clone, this does not copy the settings of the repository.
 
1650
        """
 
1651
        dest_repo = self._create_sprouting_repo(to_bzrdir, shared=False)
1202
1652
        dest_repo.fetch(self, revision_id=revision_id)
1203
1653
        return dest_repo
1204
1654
 
 
1655
    def _create_sprouting_repo(self, a_bzrdir, shared):
 
1656
        if not isinstance(a_bzrdir._format, self.bzrdir._format.__class__):
 
1657
            # use target default format.
 
1658
            dest_repo = a_bzrdir.create_repository()
 
1659
        else:
 
1660
            # Most control formats need the repository to be specifically
 
1661
            # created, but on some old all-in-one formats it's not needed
 
1662
            try:
 
1663
                dest_repo = self._format.initialize(a_bzrdir, shared=shared)
 
1664
            except errors.UninitializableFormat:
 
1665
                dest_repo = a_bzrdir.open_repository()
 
1666
        return dest_repo
 
1667
 
1205
1668
    ### These methods are just thin shims to the VFS object for now.
1206
1669
 
 
1670
    @needs_read_lock
1207
1671
    def revision_tree(self, revision_id):
1208
 
        self._ensure_real()
1209
 
        return self._real_repository.revision_tree(revision_id)
 
1672
        revision_id = _mod_revision.ensure_null(revision_id)
 
1673
        if revision_id == _mod_revision.NULL_REVISION:
 
1674
            return InventoryRevisionTree(self,
 
1675
                Inventory(root_id=None), _mod_revision.NULL_REVISION)
 
1676
        else:
 
1677
            return list(self.revision_trees([revision_id]))[0]
1210
1678
 
1211
1679
    def get_serializer_format(self):
1212
 
        self._ensure_real()
1213
 
        return self._real_repository.get_serializer_format()
 
1680
        path = self.bzrdir._path_for_remote_call(self._client)
 
1681
        try:
 
1682
            response = self._call('VersionedFileRepository.get_serializer_format',
 
1683
                path)
 
1684
        except errors.UnknownSmartMethod:
 
1685
            self._ensure_real()
 
1686
            return self._real_repository.get_serializer_format()
 
1687
        if response[0] != 'ok':
 
1688
            raise errors.UnexpectedSmartServerResponse(response)
 
1689
        return response[1]
1214
1690
 
1215
1691
    def get_commit_builder(self, branch, parents, config, timestamp=None,
1216
1692
                           timezone=None, committer=None, revprops=None,
1217
 
                           revision_id=None):
 
1693
                           revision_id=None, lossy=False):
1218
1694
        # FIXME: It ought to be possible to call this without immediately
1219
1695
        # triggering _ensure_real.  For now it's the easiest thing to do.
1220
1696
        self._ensure_real()
1221
1697
        real_repo = self._real_repository
1222
1698
        builder = real_repo.get_commit_builder(branch, parents,
1223
1699
                config, timestamp=timestamp, timezone=timezone,
1224
 
                committer=committer, revprops=revprops, revision_id=revision_id)
 
1700
                committer=committer, revprops=revprops,
 
1701
                revision_id=revision_id, lossy=lossy)
1225
1702
        return builder
1226
1703
 
1227
1704
    def add_fallback_repository(self, repository):
1235
1712
        # We need to accumulate additional repositories here, to pass them in
1236
1713
        # on various RPC's.
1237
1714
        #
 
1715
        # Make the check before we lock: this raises an exception.
 
1716
        self._check_fallback_repository(repository)
1238
1717
        if self.is_locked():
1239
1718
            # We will call fallback.unlock() when we transition to the unlocked
1240
1719
            # state, so always add a lock here. If a caller passes us a locked
1241
1720
            # repository, they are responsible for unlocking it later.
1242
1721
            repository.lock_read()
1243
 
        self._check_fallback_repository(repository)
1244
1722
        self._fallback_repositories.append(repository)
1245
1723
        # If self._real_repository was parameterised already (e.g. because a
1246
1724
        # _real_branch had its get_stacked_on_url method called), then the
1288
1766
 
1289
1767
    @needs_read_lock
1290
1768
    def get_revision(self, revision_id):
1291
 
        self._ensure_real()
1292
 
        return self._real_repository.get_revision(revision_id)
 
1769
        return self.get_revisions([revision_id])[0]
1293
1770
 
1294
1771
    def get_transaction(self):
1295
1772
        self._ensure_real()
1297
1774
 
1298
1775
    @needs_read_lock
1299
1776
    def clone(self, a_bzrdir, revision_id=None):
1300
 
        self._ensure_real()
1301
 
        return self._real_repository.clone(a_bzrdir, revision_id=revision_id)
 
1777
        dest_repo = self._create_sprouting_repo(
 
1778
            a_bzrdir, shared=self.is_shared())
 
1779
        self.copy_content_into(dest_repo, revision_id)
 
1780
        return dest_repo
1302
1781
 
1303
1782
    def make_working_trees(self):
1304
1783
        """See Repository.make_working_trees"""
1305
 
        self._ensure_real()
1306
 
        return self._real_repository.make_working_trees()
 
1784
        path = self.bzrdir._path_for_remote_call(self._client)
 
1785
        try:
 
1786
            response = self._call('Repository.make_working_trees', path)
 
1787
        except errors.UnknownSmartMethod:
 
1788
            self._ensure_real()
 
1789
            return self._real_repository.make_working_trees()
 
1790
        if response[0] not in ('yes', 'no'):
 
1791
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
1792
        return response[0] == 'yes'
1307
1793
 
1308
1794
    def refresh_data(self):
1309
 
        """Re-read any data needed to to synchronise with disk.
 
1795
        """Re-read any data needed to synchronise with disk.
1310
1796
 
1311
1797
        This method is intended to be called after another repository instance
1312
1798
        (such as one used by a smart server) has inserted data into the
1313
 
        repository. It may not be called during a write group, but may be
1314
 
        called at any other time.
 
1799
        repository. On all repositories this will work outside of write groups.
 
1800
        Some repository formats (pack and newer for bzrlib native formats)
 
1801
        support refresh_data inside write groups. If called inside a write
 
1802
        group on a repository that does not support refreshing in a write group
 
1803
        IsInWriteGroupError will be raised.
1315
1804
        """
1316
 
        if self.is_in_write_group():
1317
 
            raise errors.InternalBzrError(
1318
 
                "May not refresh_data while in a write group.")
1319
1805
        if self._real_repository is not None:
1320
1806
            self._real_repository.refresh_data()
1321
1807
 
1333
1819
        return result
1334
1820
 
1335
1821
    @needs_read_lock
1336
 
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
 
1822
    def search_missing_revision_ids(self, other,
 
1823
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
 
1824
            find_ghosts=True, revision_ids=None, if_present_ids=None,
 
1825
            limit=None):
1337
1826
        """Return the revision ids that other has that this does not.
1338
1827
 
1339
1828
        These are returned in topological order.
1340
1829
 
1341
1830
        revision_id: only return revision ids included by revision_id.
1342
1831
        """
1343
 
        return repository.InterRepository.get(
1344
 
            other, self).search_missing_revision_ids(revision_id, find_ghosts)
 
1832
        if symbol_versioning.deprecated_passed(revision_id):
 
1833
            symbol_versioning.warn(
 
1834
                'search_missing_revision_ids(revision_id=...) was '
 
1835
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
 
1836
                DeprecationWarning, stacklevel=2)
 
1837
            if revision_ids is not None:
 
1838
                raise AssertionError(
 
1839
                    'revision_ids is mutually exclusive with revision_id')
 
1840
            if revision_id is not None:
 
1841
                revision_ids = [revision_id]
 
1842
        inter_repo = _mod_repository.InterRepository.get(other, self)
 
1843
        return inter_repo.search_missing_revision_ids(
 
1844
            find_ghosts=find_ghosts, revision_ids=revision_ids,
 
1845
            if_present_ids=if_present_ids, limit=limit)
1345
1846
 
1346
 
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
 
1847
    def fetch(self, source, revision_id=None, find_ghosts=False,
1347
1848
            fetch_spec=None):
1348
1849
        # No base implementation to use as RemoteRepository is not a subclass
1349
1850
        # of Repository; so this is a copy of Repository.fetch().
1360
1861
            # check that last_revision is in 'from' and then return a
1361
1862
            # no-operation.
1362
1863
            if (revision_id is not None and
1363
 
                not revision.is_null(revision_id)):
 
1864
                not _mod_revision.is_null(revision_id)):
1364
1865
                self.get_revision(revision_id)
1365
1866
            return 0, []
1366
1867
        # if there is no specific appropriate InterRepository, this will get
1367
1868
        # the InterRepository base class, which raises an
1368
1869
        # IncompatibleRepositories when asked to fetch.
1369
 
        inter = repository.InterRepository.get(source, self)
1370
 
        return inter.fetch(revision_id=revision_id, pb=pb,
 
1870
        inter = _mod_repository.InterRepository.get(source, self)
 
1871
        return inter.fetch(revision_id=revision_id,
1371
1872
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1372
1873
 
1373
1874
    def create_bundle(self, target, base, fileobj, format=None):
1375
1876
        self._real_repository.create_bundle(target, base, fileobj, format)
1376
1877
 
1377
1878
    @needs_read_lock
 
1879
    @symbol_versioning.deprecated_method(
 
1880
        symbol_versioning.deprecated_in((2, 4, 0)))
1378
1881
    def get_ancestry(self, revision_id, topo_sorted=True):
1379
1882
        self._ensure_real()
1380
1883
        return self._real_repository.get_ancestry(revision_id, topo_sorted)
1394
1897
        self._ensure_real()
1395
1898
        return self._real_repository.iter_files_bytes(desired_files)
1396
1899
 
 
1900
    def get_cached_parent_map(self, revision_ids):
 
1901
        """See bzrlib.CachingParentsProvider.get_cached_parent_map"""
 
1902
        return self._unstacked_provider.get_cached_parent_map(revision_ids)
 
1903
 
1397
1904
    def get_parent_map(self, revision_ids):
1398
1905
        """See bzrlib.Graph.get_parent_map()."""
1399
1906
        return self._make_parents_provider().get_parent_map(revision_ids)
1457
1964
        if parents_map is None:
1458
1965
            # Repository is not locked, so there's no cache.
1459
1966
            parents_map = {}
1460
 
        # start_set is all the keys in the cache
1461
 
        start_set = set(parents_map)
1462
 
        # result set is all the references to keys in the cache
1463
 
        result_parents = set()
1464
 
        for parents in parents_map.itervalues():
1465
 
            result_parents.update(parents)
1466
 
        stop_keys = result_parents.difference(start_set)
1467
 
        # We don't need to send ghosts back to the server as a position to
1468
 
        # stop either.
1469
 
        stop_keys.difference_update(self._unstacked_provider.missing_keys)
1470
 
        key_count = len(parents_map)
1471
 
        if (NULL_REVISION in result_parents
1472
 
            and NULL_REVISION in self._unstacked_provider.missing_keys):
1473
 
            # If we pruned NULL_REVISION from the stop_keys because it's also
1474
 
            # in our cache of "missing" keys we need to increment our key count
1475
 
            # by 1, because the reconsitituted SearchResult on the server will
1476
 
            # still consider NULL_REVISION to be an included key.
1477
 
            key_count += 1
1478
 
        included_keys = start_set.intersection(result_parents)
1479
 
        start_set.difference_update(included_keys)
 
1967
        if _DEFAULT_SEARCH_DEPTH <= 0:
 
1968
            (start_set, stop_keys,
 
1969
             key_count) = graph.search_result_from_parent_map(
 
1970
                parents_map, self._unstacked_provider.missing_keys)
 
1971
        else:
 
1972
            (start_set, stop_keys,
 
1973
             key_count) = graph.limited_search_result_from_parent_map(
 
1974
                parents_map, self._unstacked_provider.missing_keys,
 
1975
                keys, depth=_DEFAULT_SEARCH_DEPTH)
1480
1976
        recipe = ('manual', start_set, stop_keys, key_count)
1481
1977
        body = self._serialise_search_recipe(recipe)
1482
1978
        path = self.bzrdir._path_for_remote_call(self._client)
1544
2040
        return self._real_repository.reconcile(other=other, thorough=thorough)
1545
2041
 
1546
2042
    def all_revision_ids(self):
1547
 
        self._ensure_real()
1548
 
        return self._real_repository.all_revision_ids()
 
2043
        path = self.bzrdir._path_for_remote_call(self._client)
 
2044
        try:
 
2045
            response_tuple, response_handler = self._call_expecting_body(
 
2046
                "Repository.all_revision_ids", path)
 
2047
        except errors.UnknownSmartMethod:
 
2048
            self._ensure_real()
 
2049
            return self._real_repository.all_revision_ids()
 
2050
        if response_tuple != ("ok", ):
 
2051
            raise errors.UnexpectedSmartServerResponse(response_tuple)
 
2052
        revids = set(response_handler.read_body_bytes().splitlines())
 
2053
        for fallback in self._fallback_repositories:
 
2054
            revids.update(set(fallback.all_revision_ids()))
 
2055
        return list(revids)
1549
2056
 
1550
2057
    @needs_read_lock
1551
2058
    def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1555
2062
 
1556
2063
    @needs_read_lock
1557
2064
    def get_revision_delta(self, revision_id, specific_fileids=None):
1558
 
        self._ensure_real()
1559
 
        return self._real_repository.get_revision_delta(revision_id,
1560
 
            specific_fileids=specific_fileids)
 
2065
        r = self.get_revision(revision_id)
 
2066
        return list(self.get_deltas_for_revisions([r],
 
2067
            specific_fileids=specific_fileids))[0]
1561
2068
 
1562
2069
    @needs_read_lock
1563
2070
    def revision_trees(self, revision_ids):
1576
2083
            callback_refs=callback_refs, check_repo=check_repo)
1577
2084
 
1578
2085
    def copy_content_into(self, destination, revision_id=None):
1579
 
        self._ensure_real()
1580
 
        return self._real_repository.copy_content_into(
1581
 
            destination, revision_id=revision_id)
 
2086
        """Make a complete copy of the content in self into destination.
 
2087
 
 
2088
        This is a destructive operation! Do not use it on existing
 
2089
        repositories.
 
2090
        """
 
2091
        interrepo = _mod_repository.InterRepository.get(self, destination)
 
2092
        return interrepo.copy_content(revision_id)
1582
2093
 
1583
2094
    def _copy_repository_tarball(self, to_bzrdir, revision_id=None):
1584
2095
        # get a tarball of the remote repository, and copy from that into the
1586
2097
        from bzrlib import osutils
1587
2098
        import tarfile
1588
2099
        # TODO: Maybe a progress bar while streaming the tarball?
1589
 
        note("Copying repository content as tarball...")
 
2100
        note(gettext("Copying repository content as tarball..."))
1590
2101
        tar_file = self._get_tarball('bz2')
1591
2102
        if tar_file is None:
1592
2103
            return None
1597
2108
            tmpdir = osutils.mkdtemp()
1598
2109
            try:
1599
2110
                _extract_tar(tar, tmpdir)
1600
 
                tmp_bzrdir = BzrDir.open(tmpdir)
 
2111
                tmp_bzrdir = _mod_bzrdir.BzrDir.open(tmpdir)
1601
2112
                tmp_repo = tmp_bzrdir.open_repository()
1602
2113
                tmp_repo.copy_content_into(destination, revision_id)
1603
2114
            finally:
1688
2199
    def supports_rich_root(self):
1689
2200
        return self._format.rich_root_data
1690
2201
 
 
2202
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
1691
2203
    def iter_reverse_revision_history(self, revision_id):
1692
2204
        self._ensure_real()
1693
2205
        return self._real_repository.iter_reverse_revision_history(revision_id)
1696
2208
    def _serializer(self):
1697
2209
        return self._format._serializer
1698
2210
 
 
2211
    @needs_write_lock
1699
2212
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
1700
 
        self._ensure_real()
1701
 
        return self._real_repository.store_revision_signature(
1702
 
            gpg_strategy, plaintext, revision_id)
 
2213
        signature = gpg_strategy.sign(plaintext)
 
2214
        self.add_signature_text(revision_id, signature)
1703
2215
 
1704
2216
    def add_signature_text(self, revision_id, signature):
1705
2217
        self._ensure_real()
1706
2218
        return self._real_repository.add_signature_text(revision_id, signature)
1707
2219
 
1708
2220
    def has_signature_for_revision_id(self, revision_id):
 
2221
        path = self.bzrdir._path_for_remote_call(self._client)
 
2222
        try:
 
2223
            response = self._call('Repository.has_signature_for_revision_id',
 
2224
                path, revision_id)
 
2225
        except errors.UnknownSmartMethod:
 
2226
            self._ensure_real()
 
2227
            return self._real_repository.has_signature_for_revision_id(
 
2228
                revision_id)
 
2229
        if response[0] not in ('yes', 'no'):
 
2230
            raise SmartProtocolError('unexpected response code %s' % (response,))
 
2231
        return (response[0] == 'yes')
 
2232
 
 
2233
    def verify_revision_signature(self, revision_id, gpg_strategy):
1709
2234
        self._ensure_real()
1710
 
        return self._real_repository.has_signature_for_revision_id(revision_id)
 
2235
        return self._real_repository.verify_revision_signature(
 
2236
            revision_id, gpg_strategy)
1711
2237
 
1712
2238
    def item_keys_introduced_by(self, revision_ids, _files_pb=None):
1713
2239
        self._ensure_real()
1714
2240
        return self._real_repository.item_keys_introduced_by(revision_ids,
1715
2241
            _files_pb=_files_pb)
1716
2242
 
1717
 
    def revision_graph_can_have_wrong_parents(self):
1718
 
        # The answer depends on the remote repo format.
1719
 
        self._ensure_real()
1720
 
        return self._real_repository.revision_graph_can_have_wrong_parents()
1721
 
 
1722
2243
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
1723
2244
        self._ensure_real()
1724
2245
        return self._real_repository._find_inconsistent_revision_parents(
1732
2253
        providers = [self._unstacked_provider]
1733
2254
        if other is not None:
1734
2255
            providers.insert(0, other)
1735
 
        providers.extend(r._make_parents_provider() for r in
1736
 
                         self._fallback_repositories)
1737
 
        return graph.StackedParentsProvider(providers)
 
2256
        return graph.StackedParentsProvider(_LazyListJoin(
 
2257
            providers, self._fallback_repositories))
1738
2258
 
1739
2259
    def _serialise_search_recipe(self, recipe):
1740
2260
        """Serialise a graph search recipe.
1748
2268
        return '\n'.join((start_keys, stop_keys, count))
1749
2269
 
1750
2270
    def _serialise_search_result(self, search_result):
1751
 
        if isinstance(search_result, graph.PendingAncestryResult):
1752
 
            parts = ['ancestry-of']
1753
 
            parts.extend(search_result.heads)
1754
 
        else:
1755
 
            recipe = search_result.get_recipe()
1756
 
            parts = [recipe[0], self._serialise_search_recipe(recipe)]
 
2271
        parts = search_result.get_network_struct()
1757
2272
        return '\n'.join(parts)
1758
2273
 
1759
2274
    def autopack(self):
1769
2284
            raise errors.UnexpectedSmartServerResponse(response)
1770
2285
 
1771
2286
 
1772
 
class RemoteStreamSink(repository.StreamSink):
 
2287
class RemoteStreamSink(vf_repository.StreamSink):
1773
2288
 
1774
2289
    def _insert_real(self, stream, src_format, resume_tokens):
1775
2290
        self.target_repo._ensure_real()
1876
2391
        self._last_substream and self._last_stream so that the stream can be
1877
2392
        resumed by _resume_stream_with_vfs.
1878
2393
        """
1879
 
                    
 
2394
 
1880
2395
        stream_iter = iter(stream)
1881
2396
        for substream_kind, substream in stream_iter:
1882
2397
            if substream_kind == 'inventory-deltas':
1885
2400
                return
1886
2401
            else:
1887
2402
                yield substream_kind, substream
1888
 
            
1889
 
 
1890
 
class RemoteStreamSource(repository.StreamSource):
 
2403
 
 
2404
 
 
2405
class RemoteStreamSource(vf_repository.StreamSource):
1891
2406
    """Stream data from a remote server."""
1892
2407
 
1893
2408
    def get_stream(self, search):
1953
2468
        candidate_verbs = [
1954
2469
            ('Repository.get_stream_1.19', (1, 19)),
1955
2470
            ('Repository.get_stream', (1, 13))]
 
2471
 
1956
2472
        found_verb = False
1957
2473
        for verb, version in candidate_verbs:
1958
2474
            if medium._is_remote_before(version):
1962
2478
                    verb, args, search_bytes)
1963
2479
            except errors.UnknownSmartMethod:
1964
2480
                medium._remember_remote_is_before(version)
 
2481
            except errors.UnknownErrorFromSmartServer, e:
 
2482
                if isinstance(search, graph.EverythingResult):
 
2483
                    error_verb = e.error_from_smart_server.error_verb
 
2484
                    if error_verb == 'BadSearch':
 
2485
                        # Pre-2.4 servers don't support this sort of search.
 
2486
                        # XXX: perhaps falling back to VFS on BadSearch is a
 
2487
                        # good idea in general?  It might provide a little bit
 
2488
                        # of protection against client-side bugs.
 
2489
                        medium._remember_remote_is_before((2, 4))
 
2490
                        break
 
2491
                raise
1965
2492
            else:
1966
2493
                response_tuple, response_handler = response
1967
2494
                found_verb = True
1971
2498
        if response_tuple[0] != 'ok':
1972
2499
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1973
2500
        byte_stream = response_handler.read_streamed_body()
1974
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
 
2501
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
 
2502
            self._record_counter)
1975
2503
        if src_format.network_name() != repo._format.network_name():
1976
2504
            raise AssertionError(
1977
2505
                "Mismatched RemoteRepository and stream src %r, %r" % (
2063
2591
        return a_bzrdir.open_branch(name=name, 
2064
2592
            ignore_fallbacks=ignore_fallbacks)
2065
2593
 
2066
 
    def _vfs_initialize(self, a_bzrdir, name):
 
2594
    def _vfs_initialize(self, a_bzrdir, name, append_revisions_only):
2067
2595
        # Initialisation when using a local bzrdir object, or a non-vfs init
2068
2596
        # method is not available on the server.
2069
2597
        # self._custom_format is always set - the start of initialize ensures
2071
2599
        if isinstance(a_bzrdir, RemoteBzrDir):
2072
2600
            a_bzrdir._ensure_real()
2073
2601
            result = self._custom_format.initialize(a_bzrdir._real_bzrdir,
2074
 
                name)
 
2602
                name, append_revisions_only=append_revisions_only)
2075
2603
        else:
2076
2604
            # We assume the bzrdir is parameterised; it may not be.
2077
 
            result = self._custom_format.initialize(a_bzrdir, name)
 
2605
            result = self._custom_format.initialize(a_bzrdir, name,
 
2606
                append_revisions_only=append_revisions_only)
2078
2607
        if (isinstance(a_bzrdir, RemoteBzrDir) and
2079
2608
            not isinstance(result, RemoteBranch)):
2080
2609
            result = RemoteBranch(a_bzrdir, a_bzrdir.find_repository(), result,
2081
2610
                                  name=name)
2082
2611
        return result
2083
2612
 
2084
 
    def initialize(self, a_bzrdir, name=None):
 
2613
    def initialize(self, a_bzrdir, name=None, repository=None,
 
2614
                   append_revisions_only=None):
2085
2615
        # 1) get the network name to use.
2086
2616
        if self._custom_format:
2087
2617
            network_name = self._custom_format.network_name()
2088
2618
        else:
2089
2619
            # Select the current bzrlib default and ask for that.
2090
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
2620
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
2091
2621
            reference_format = reference_bzrdir_format.get_branch_format()
2092
2622
            self._custom_format = reference_format
2093
2623
            network_name = reference_format.network_name()
2094
2624
        # Being asked to create on a non RemoteBzrDir:
2095
2625
        if not isinstance(a_bzrdir, RemoteBzrDir):
2096
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2626
            return self._vfs_initialize(a_bzrdir, name=name,
 
2627
                append_revisions_only=append_revisions_only)
2097
2628
        medium = a_bzrdir._client._medium
2098
2629
        if medium._is_remote_before((1, 13)):
2099
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2630
            return self._vfs_initialize(a_bzrdir, name=name,
 
2631
                append_revisions_only=append_revisions_only)
2100
2632
        # Creating on a remote bzr dir.
2101
2633
        # 2) try direct creation via RPC
2102
2634
        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)
2109
2641
        except errors.UnknownSmartMethod:
2110
2642
            # Fallback - use vfs methods
2111
2643
            medium._remember_remote_is_before((1, 13))
2112
 
            return self._vfs_initialize(a_bzrdir, name=name)
 
2644
            return self._vfs_initialize(a_bzrdir, name=name,
 
2645
                    append_revisions_only=append_revisions_only)
2113
2646
        if response[0] != 'ok':
2114
2647
            raise errors.UnexpectedSmartServerResponse(response)
2115
2648
        # Turn the response into a RemoteRepository object.
2116
2649
        format = RemoteBranchFormat(network_name=response[1])
2117
2650
        repo_format = response_tuple_to_repo_format(response[3:])
2118
 
        if response[2] == '':
2119
 
            repo_bzrdir = a_bzrdir
 
2651
        repo_path = response[2]
 
2652
        if repository is not None:
 
2653
            remote_repo_url = urlutils.join(a_bzrdir.user_url, repo_path)
 
2654
            url_diff = urlutils.relative_url(repository.user_url,
 
2655
                    remote_repo_url)
 
2656
            if url_diff != '.':
 
2657
                raise AssertionError(
 
2658
                    'repository.user_url %r does not match URL from server '
 
2659
                    'response (%r + %r)'
 
2660
                    % (repository.user_url, a_bzrdir.user_url, repo_path))
 
2661
            remote_repo = repository
2120
2662
        else:
2121
 
            repo_bzrdir = RemoteBzrDir(
2122
 
                a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
2123
 
                a_bzrdir._client)
2124
 
        remote_repo = RemoteRepository(repo_bzrdir, repo_format)
 
2663
            if repo_path == '':
 
2664
                repo_bzrdir = a_bzrdir
 
2665
            else:
 
2666
                repo_bzrdir = RemoteBzrDir(
 
2667
                    a_bzrdir.root_transport.clone(repo_path), a_bzrdir._format,
 
2668
                    a_bzrdir._client)
 
2669
            remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2125
2670
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2126
2671
            format=format, setup_stacking=False, name=name)
 
2672
        if append_revisions_only:
 
2673
            remote_branch.set_append_revisions_only(append_revisions_only)
2127
2674
        # XXX: We know this is a new branch, so it must have revno 0, revid
2128
2675
        # NULL_REVISION. Creating the branch locked would make this be unable
2129
2676
        # to be wrong; here its simply very unlikely to be wrong. RBC 20090225
2148
2695
        self._ensure_real()
2149
2696
        return self._custom_format.supports_set_append_revisions_only()
2150
2697
 
 
2698
    def _use_default_local_heads_to_fetch(self):
 
2699
        # If the branch format is a metadir format *and* its heads_to_fetch
 
2700
        # implementation is not overridden vs the base class, we can use the
 
2701
        # base class logic rather than use the heads_to_fetch RPC.  This is
 
2702
        # usually cheaper in terms of net round trips, as the last-revision and
 
2703
        # tags info fetched is cached and would be fetched anyway.
 
2704
        self._ensure_real()
 
2705
        if isinstance(self._custom_format, branch.BranchFormatMetadir):
 
2706
            branch_class = self._custom_format._branch_class()
 
2707
            heads_to_fetch_impl = branch_class.heads_to_fetch.im_func
 
2708
            if heads_to_fetch_impl is branch.Branch.heads_to_fetch.im_func:
 
2709
                return True
 
2710
        return False
 
2711
 
 
2712
 
 
2713
class RemoteBranchStore(config.IniFileStore):
 
2714
    """Branch store which attempts to use HPSS calls to retrieve branch store.
 
2715
 
 
2716
    Note that this is specific to bzr-based formats.
 
2717
    """
 
2718
 
 
2719
    def __init__(self, branch):
 
2720
        super(RemoteBranchStore, self).__init__()
 
2721
        self.branch = branch
 
2722
        self.id = "branch"
 
2723
        self._real_store = None
 
2724
 
 
2725
    def lock_write(self, token=None):
 
2726
        return self.branch.lock_write(token)
 
2727
 
 
2728
    def unlock(self):
 
2729
        return self.branch.unlock()
 
2730
 
 
2731
    @needs_write_lock
 
2732
    def save(self):
 
2733
        # We need to be able to override the undecorated implementation
 
2734
        self.save_without_locking()
 
2735
 
 
2736
    def save_without_locking(self):
 
2737
        super(RemoteBranchStore, self).save()
 
2738
 
 
2739
    def external_url(self):
 
2740
        return self.branch.user_url
 
2741
 
 
2742
    def _load_content(self):
 
2743
        path = self.branch._remote_path()
 
2744
        try:
 
2745
            response, handler = self.branch._call_expecting_body(
 
2746
                'Branch.get_config_file', path)
 
2747
        except errors.UnknownSmartMethod:
 
2748
            self._ensure_real()
 
2749
            return self._real_store._load_content()
 
2750
        if len(response) and response[0] != 'ok':
 
2751
            raise errors.UnexpectedSmartServerResponse(response)
 
2752
        return handler.read_body_bytes()
 
2753
 
 
2754
    def _save_content(self, content):
 
2755
        path = self.branch._remote_path()
 
2756
        try:
 
2757
            response, handler = self.branch._call_with_body_bytes_expecting_body(
 
2758
                'Branch.put_config_file', (path,
 
2759
                    self.branch._lock_token, self.branch._repo_lock_token),
 
2760
                content)
 
2761
        except errors.UnknownSmartMethod:
 
2762
            self._ensure_real()
 
2763
            return self._real_store._save_content(content)
 
2764
        handler.cancel_read_body()
 
2765
        if response != ('ok', ):
 
2766
            raise errors.UnexpectedSmartServerResponse(response)
 
2767
 
 
2768
    def _ensure_real(self):
 
2769
        self.branch._ensure_real()
 
2770
        if self._real_store is None:
 
2771
            self._real_store = config.BranchStore(self.branch)
 
2772
 
2151
2773
 
2152
2774
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
2153
2775
    """Branch stored on a server accessed by HPSS RPC.
2238
2860
            errors.UnstackableRepositoryFormat), e:
2239
2861
            return
2240
2862
        self._is_stacked = True
2241
 
        self._activate_fallback_location(fallback_url)
 
2863
        self._activate_fallback_location(fallback_url,
 
2864
            possible_transports=[self.control_transport])
2242
2865
 
2243
2866
    def _get_config(self):
2244
2867
        return RemoteBranchConfig(self)
2245
2868
 
 
2869
    def _get_config_store(self):
 
2870
        return RemoteBranchStore(self)
 
2871
 
2246
2872
    def _get_real_transport(self):
2247
2873
        # if we try vfs access, return the real branch's vfs transport
2248
2874
        self._ensure_real()
2311
2937
                self.bzrdir, self._client)
2312
2938
        return self._control_files
2313
2939
 
2314
 
    def _get_checkout_format(self):
 
2940
    def _get_checkout_format(self, lightweight=False):
2315
2941
        self._ensure_real()
2316
 
        return self._real_branch._get_checkout_format()
 
2942
        if lightweight:
 
2943
            format = RemoteBzrDirFormat()
 
2944
            self.bzrdir._format._supply_sub_formats_to(format)
 
2945
            format.workingtree_format = self._real_branch._get_checkout_format(
 
2946
                lightweight=lightweight).workingtree_format
 
2947
            return format
 
2948
        else:
 
2949
            return self._real_branch._get_checkout_format(lightweight=False)
2317
2950
 
2318
2951
    def get_physical_lock_status(self):
2319
2952
        """See Branch.get_physical_lock_status()."""
2320
 
        # should be an API call to the server, as branches must be lockable.
2321
 
        self._ensure_real()
2322
 
        return self._real_branch.get_physical_lock_status()
 
2953
        try:
 
2954
            response = self._client.call('Branch.get_physical_lock_status',
 
2955
                self._remote_path())
 
2956
        except errors.UnknownSmartMethod:
 
2957
            self._ensure_real()
 
2958
            return self._real_branch.get_physical_lock_status()
 
2959
        if response[0] not in ('yes', 'no'):
 
2960
            raise errors.UnexpectedSmartServerResponse(response)
 
2961
        return (response[0] == 'yes')
2323
2962
 
2324
2963
    def get_stacked_on_url(self):
2325
2964
        """Get the URL this branch is stacked against.
2352
2991
            self._is_stacked = False
2353
2992
        else:
2354
2993
            self._is_stacked = True
2355
 
        
 
2994
 
2356
2995
    def _vfs_get_tags_bytes(self):
2357
2996
        self._ensure_real()
2358
2997
        return self._real_branch._get_tags_bytes()
2359
2998
 
 
2999
    @needs_read_lock
2360
3000
    def _get_tags_bytes(self):
 
3001
        if self._tags_bytes is None:
 
3002
            self._tags_bytes = self._get_tags_bytes_via_hpss()
 
3003
        return self._tags_bytes
 
3004
 
 
3005
    def _get_tags_bytes_via_hpss(self):
2361
3006
        medium = self._client._medium
2362
3007
        if medium._is_remote_before((1, 13)):
2363
3008
            return self._vfs_get_tags_bytes()
2373
3018
        return self._real_branch._set_tags_bytes(bytes)
2374
3019
 
2375
3020
    def _set_tags_bytes(self, bytes):
 
3021
        if self.is_locked():
 
3022
            self._tags_bytes = bytes
2376
3023
        medium = self._client._medium
2377
3024
        if medium._is_remote_before((1, 18)):
2378
3025
            self._vfs_set_tags_bytes(bytes)
2387
3034
            self._vfs_set_tags_bytes(bytes)
2388
3035
 
2389
3036
    def lock_read(self):
 
3037
        """Lock the branch for read operations.
 
3038
 
 
3039
        :return: A bzrlib.lock.LogicalLockResult.
 
3040
        """
2390
3041
        self.repository.lock_read()
2391
3042
        if not self._lock_mode:
2392
3043
            self._note_lock('r')
2396
3047
                self._real_branch.lock_read()
2397
3048
        else:
2398
3049
            self._lock_count += 1
 
3050
        return lock.LogicalLockResult(self.unlock)
2399
3051
 
2400
3052
    def _remote_lock_write(self, token):
2401
3053
        if token is None:
2402
3054
            branch_token = repo_token = ''
2403
3055
        else:
2404
3056
            branch_token = token
2405
 
            repo_token = self.repository.lock_write()
 
3057
            repo_token = self.repository.lock_write().repository_token
2406
3058
            self.repository.unlock()
2407
3059
        err_context = {'token': token}
2408
 
        response = self._call(
2409
 
            'Branch.lock_write', self._remote_path(), branch_token,
2410
 
            repo_token or '', **err_context)
 
3060
        try:
 
3061
            response = self._call(
 
3062
                'Branch.lock_write', self._remote_path(), branch_token,
 
3063
                repo_token or '', **err_context)
 
3064
        except errors.LockContention, e:
 
3065
            # The LockContention from the server doesn't have any
 
3066
            # information about the lock_url. We re-raise LockContention
 
3067
            # with valid lock_url.
 
3068
            raise errors.LockContention('(remote lock)',
 
3069
                self.repository.base.split('.bzr/')[0])
2411
3070
        if response[0] != 'ok':
2412
3071
            raise errors.UnexpectedSmartServerResponse(response)
2413
3072
        ok, branch_token, repo_token = response
2434
3093
            self._lock_mode = 'w'
2435
3094
            self._lock_count = 1
2436
3095
        elif self._lock_mode == 'r':
2437
 
            raise errors.ReadOnlyTransaction
 
3096
            raise errors.ReadOnlyError(self)
2438
3097
        else:
2439
3098
            if token is not None:
2440
3099
                # A token was given to lock_write, and we're relocking, so
2445
3104
            self._lock_count += 1
2446
3105
            # Re-lock the repository too.
2447
3106
            self.repository.lock_write(self._repo_lock_token)
2448
 
        return self._lock_token or None
 
3107
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
2449
3108
 
2450
3109
    def _unlock(self, branch_token, repo_token):
2451
3110
        err_context = {'token': str((branch_token, repo_token))}
2489
3148
            self.repository.unlock()
2490
3149
 
2491
3150
    def break_lock(self):
2492
 
        self._ensure_real()
2493
 
        return self._real_branch.break_lock()
 
3151
        try:
 
3152
            response = self._call(
 
3153
                'Branch.break_lock', self._remote_path())
 
3154
        except errors.UnknownSmartMethod:
 
3155
            self._ensure_real()
 
3156
            return self._real_branch.break_lock()
 
3157
        if response != ('ok',):
 
3158
            raise errors.UnexpectedSmartServerResponse(response)
2494
3159
 
2495
3160
    def leave_lock_in_place(self):
2496
3161
        if not self._lock_token:
2520
3185
            missing_parent = parent_map[missing_parent]
2521
3186
        raise errors.RevisionNotPresent(missing_parent, self.repository)
2522
3187
 
2523
 
    def _last_revision_info(self):
 
3188
    def _read_last_revision_info(self):
2524
3189
        response = self._call('Branch.last_revision_info', self._remote_path())
2525
3190
        if response[0] != 'ok':
2526
3191
            raise SmartProtocolError('unexpected response code %s' % (response,))
2589
3254
            raise errors.UnexpectedSmartServerResponse(response)
2590
3255
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2591
3256
 
 
3257
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2592
3258
    @needs_write_lock
2593
3259
    def set_revision_history(self, rev_history):
 
3260
        """See Branch.set_revision_history."""
 
3261
        self._set_revision_history(rev_history)
 
3262
 
 
3263
    @needs_write_lock
 
3264
    def _set_revision_history(self, rev_history):
2594
3265
        # Send just the tip revision of the history; the server will generate
2595
3266
        # the full history from that.  If the revision doesn't exist in this
2596
3267
        # branch, NoSuchRevision will be raised.
2654
3325
            _override_hook_target=self, **kwargs)
2655
3326
 
2656
3327
    @needs_read_lock
2657
 
    def push(self, target, overwrite=False, stop_revision=None):
 
3328
    def push(self, target, overwrite=False, stop_revision=None, lossy=False):
2658
3329
        self._ensure_real()
2659
3330
        return self._real_branch.push(
2660
 
            target, overwrite=overwrite, stop_revision=stop_revision,
 
3331
            target, overwrite=overwrite, stop_revision=stop_revision, lossy=lossy,
2661
3332
            _override_hook_source_branch=self)
2662
3333
 
2663
3334
    def is_locked(self):
2664
3335
        return self._lock_count >= 1
2665
3336
 
2666
3337
    @needs_read_lock
 
3338
    def revision_id_to_dotted_revno(self, revision_id):
 
3339
        """Given a revision id, return its dotted revno.
 
3340
 
 
3341
        :return: a tuple like (1,) or (400,1,3).
 
3342
        """
 
3343
        try:
 
3344
            response = self._call('Branch.revision_id_to_revno',
 
3345
                self._remote_path(), revision_id)
 
3346
        except errors.UnknownSmartMethod:
 
3347
            self._ensure_real()
 
3348
            return self._real_branch.revision_id_to_revno(revision_id)
 
3349
        if response[0] == 'ok':
 
3350
            return tuple([int(x) for x in response[1:]])
 
3351
        else:
 
3352
            raise errors.UnexpectedSmartServerResponse(response)
 
3353
 
 
3354
    @needs_read_lock
2667
3355
    def revision_id_to_revno(self, revision_id):
2668
 
        self._ensure_real()
2669
 
        return self._real_branch.revision_id_to_revno(revision_id)
 
3356
        """Given a revision id on the branch mainline, return its revno.
 
3357
 
 
3358
        :return: an integer
 
3359
        """
 
3360
        try:
 
3361
            response = self._call('Branch.revision_id_to_revno',
 
3362
                self._remote_path(), revision_id)
 
3363
        except errors.UnknownSmartMethod:
 
3364
            self._ensure_real()
 
3365
            return self._real_branch.revision_id_to_revno(revision_id)
 
3366
        if response[0] == 'ok':
 
3367
            if len(response) == 2:
 
3368
                return int(response[1])
 
3369
            raise NoSuchRevision(self, revision_id)
 
3370
        else:
 
3371
            raise errors.UnexpectedSmartServerResponse(response)
2670
3372
 
2671
3373
    @needs_write_lock
2672
3374
    def set_last_revision_info(self, revno, revision_id):
2673
3375
        # XXX: These should be returned by the set_last_revision_info verb
2674
3376
        old_revno, old_revid = self.last_revision_info()
2675
3377
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
2676
 
        revision_id = ensure_null(revision_id)
 
3378
        if not revision_id or not isinstance(revision_id, basestring):
 
3379
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2677
3380
        try:
2678
3381
            response = self._call('Branch.set_last_revision_info',
2679
3382
                self._remote_path(), self._lock_token, self._repo_lock_token,
2708
3411
            except errors.UnknownSmartMethod:
2709
3412
                medium._remember_remote_is_before((1, 6))
2710
3413
        self._clear_cached_state_of_remote_branch_only()
2711
 
        self.set_revision_history(self._lefthand_history(revision_id,
 
3414
        self._set_revision_history(self._lefthand_history(revision_id,
2712
3415
            last_rev=last_rev,other_branch=other_branch))
2713
3416
 
2714
3417
    def set_push_location(self, location):
2715
3418
        self._ensure_real()
2716
3419
        return self._real_branch.set_push_location(location)
2717
3420
 
 
3421
    def heads_to_fetch(self):
 
3422
        if self._format._use_default_local_heads_to_fetch():
 
3423
            # We recognise this format, and its heads-to-fetch implementation
 
3424
            # is the default one (tip + tags).  In this case it's cheaper to
 
3425
            # just use the default implementation rather than a special RPC as
 
3426
            # the tip and tags data is cached.
 
3427
            return branch.Branch.heads_to_fetch(self)
 
3428
        medium = self._client._medium
 
3429
        if medium._is_remote_before((2, 4)):
 
3430
            return self._vfs_heads_to_fetch()
 
3431
        try:
 
3432
            return self._rpc_heads_to_fetch()
 
3433
        except errors.UnknownSmartMethod:
 
3434
            medium._remember_remote_is_before((2, 4))
 
3435
            return self._vfs_heads_to_fetch()
 
3436
 
 
3437
    def _rpc_heads_to_fetch(self):
 
3438
        response = self._call('Branch.heads_to_fetch', self._remote_path())
 
3439
        if len(response) != 2:
 
3440
            raise errors.UnexpectedSmartServerResponse(response)
 
3441
        must_fetch, if_present_fetch = response
 
3442
        return set(must_fetch), set(if_present_fetch)
 
3443
 
 
3444
    def _vfs_heads_to_fetch(self):
 
3445
        self._ensure_real()
 
3446
        return self._real_branch.heads_to_fetch()
 
3447
 
2718
3448
 
2719
3449
class RemoteConfig(object):
2720
3450
    """A Config that reads and writes from smart verbs.
2734
3464
        """
2735
3465
        try:
2736
3466
            configobj = self._get_configobj()
 
3467
            section_obj = None
2737
3468
            if section is None:
2738
3469
                section_obj = configobj
2739
3470
            else:
2740
3471
                try:
2741
3472
                    section_obj = configobj[section]
2742
3473
                except KeyError:
2743
 
                    return default
2744
 
            return section_obj.get(name, default)
 
3474
                    pass
 
3475
            if section_obj is None:
 
3476
                value = default
 
3477
            else:
 
3478
                value = section_obj.get(name, default)
2745
3479
        except errors.UnknownSmartMethod:
2746
 
            return self._vfs_get_option(name, section, default)
 
3480
            value = self._vfs_get_option(name, section, default)
 
3481
        for hook in config.OldConfigHooks['get']:
 
3482
            hook(self, name, value)
 
3483
        return value
2747
3484
 
2748
3485
    def _response_to_configobj(self, response):
2749
3486
        if len(response[0]) and response[0][0] != 'ok':
2750
3487
            raise errors.UnexpectedSmartServerResponse(response)
2751
3488
        lines = response[1].read_body_bytes().splitlines()
2752
 
        return config.ConfigObj(lines, encoding='utf-8')
 
3489
        conf = config.ConfigObj(lines, encoding='utf-8')
 
3490
        for hook in config.OldConfigHooks['load']:
 
3491
            hook(self)
 
3492
        return conf
2753
3493
 
2754
3494
 
2755
3495
class RemoteBranchConfig(RemoteConfig):
2774
3514
        medium = self._branch._client._medium
2775
3515
        if medium._is_remote_before((1, 14)):
2776
3516
            return self._vfs_set_option(value, name, section)
 
3517
        if isinstance(value, dict):
 
3518
            if medium._is_remote_before((2, 2)):
 
3519
                return self._vfs_set_option(value, name, section)
 
3520
            return self._set_config_option_dict(value, name, section)
 
3521
        else:
 
3522
            return self._set_config_option(value, name, section)
 
3523
 
 
3524
    def _set_config_option(self, value, name, section):
2777
3525
        try:
2778
3526
            path = self._branch._remote_path()
2779
3527
            response = self._branch._client.call('Branch.set_config_option',
2780
3528
                path, self._branch._lock_token, self._branch._repo_lock_token,
2781
3529
                value.encode('utf8'), name, section or '')
2782
3530
        except errors.UnknownSmartMethod:
 
3531
            medium = self._branch._client._medium
2783
3532
            medium._remember_remote_is_before((1, 14))
2784
3533
            return self._vfs_set_option(value, name, section)
2785
3534
        if response != ():
2786
3535
            raise errors.UnexpectedSmartServerResponse(response)
2787
3536
 
 
3537
    def _serialize_option_dict(self, option_dict):
 
3538
        utf8_dict = {}
 
3539
        for key, value in option_dict.items():
 
3540
            if isinstance(key, unicode):
 
3541
                key = key.encode('utf8')
 
3542
            if isinstance(value, unicode):
 
3543
                value = value.encode('utf8')
 
3544
            utf8_dict[key] = value
 
3545
        return bencode.bencode(utf8_dict)
 
3546
 
 
3547
    def _set_config_option_dict(self, value, name, section):
 
3548
        try:
 
3549
            path = self._branch._remote_path()
 
3550
            serialised_dict = self._serialize_option_dict(value)
 
3551
            response = self._branch._client.call(
 
3552
                'Branch.set_config_option_dict',
 
3553
                path, self._branch._lock_token, self._branch._repo_lock_token,
 
3554
                serialised_dict, name, section or '')
 
3555
        except errors.UnknownSmartMethod:
 
3556
            medium = self._branch._client._medium
 
3557
            medium._remember_remote_is_before((2, 2))
 
3558
            return self._vfs_set_option(value, name, section)
 
3559
        if response != ():
 
3560
            raise errors.UnexpectedSmartServerResponse(response)
 
3561
 
2788
3562
    def _real_object(self):
2789
3563
        self._branch._ensure_real()
2790
3564
        return self._branch._real_branch
2839
3613
        tar.extract(tarinfo, to_dir)
2840
3614
 
2841
3615
 
 
3616
error_translators = registry.Registry()
 
3617
no_context_error_translators = registry.Registry()
 
3618
 
 
3619
 
2842
3620
def _translate_error(err, **context):
2843
3621
    """Translate an ErrorFromSmartServer into a more useful error.
2844
3622
 
2873
3651
                    'Missing key %r in context %r', key_err.args[0], context)
2874
3652
                raise err
2875
3653
 
2876
 
    if err.error_verb == 'IncompatibleRepositories':
2877
 
        raise errors.IncompatibleRepositories(err.error_args[0],
2878
 
            err.error_args[1], err.error_args[2])
2879
 
    elif err.error_verb == 'NoSuchRevision':
2880
 
        raise NoSuchRevision(find('branch'), err.error_args[0])
2881
 
    elif err.error_verb == 'nosuchrevision':
2882
 
        raise NoSuchRevision(find('repository'), err.error_args[0])
2883
 
    elif err.error_verb == 'nobranch':
2884
 
        if len(err.error_args) >= 1:
2885
 
            extra = err.error_args[0]
2886
 
        else:
2887
 
            extra = None
2888
 
        raise errors.NotBranchError(path=find('bzrdir').root_transport.base,
2889
 
            detail=extra)
2890
 
    elif err.error_verb == 'norepository':
2891
 
        raise errors.NoRepositoryPresent(find('bzrdir'))
2892
 
    elif err.error_verb == 'LockContention':
2893
 
        raise errors.LockContention('(remote lock)')
2894
 
    elif err.error_verb == 'UnlockableTransport':
2895
 
        raise errors.UnlockableTransport(find('bzrdir').root_transport)
2896
 
    elif err.error_verb == 'LockFailed':
2897
 
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
2898
 
    elif err.error_verb == 'TokenMismatch':
2899
 
        raise errors.TokenMismatch(find('token'), '(remote token)')
2900
 
    elif err.error_verb == 'Diverged':
2901
 
        raise errors.DivergedBranches(find('branch'), find('other_branch'))
2902
 
    elif err.error_verb == 'TipChangeRejected':
2903
 
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
2904
 
    elif err.error_verb == 'UnstackableBranchFormat':
2905
 
        raise errors.UnstackableBranchFormat(*err.error_args)
2906
 
    elif err.error_verb == 'UnstackableRepositoryFormat':
2907
 
        raise errors.UnstackableRepositoryFormat(*err.error_args)
2908
 
    elif err.error_verb == 'NotStacked':
2909
 
        raise errors.NotStacked(branch=find('branch'))
2910
 
    elif err.error_verb == 'PermissionDenied':
2911
 
        path = get_path()
2912
 
        if len(err.error_args) >= 2:
2913
 
            extra = err.error_args[1]
2914
 
        else:
2915
 
            extra = None
2916
 
        raise errors.PermissionDenied(path, extra=extra)
2917
 
    elif err.error_verb == 'ReadError':
2918
 
        path = get_path()
2919
 
        raise errors.ReadError(path)
2920
 
    elif err.error_verb == 'NoSuchFile':
2921
 
        path = get_path()
2922
 
        raise errors.NoSuchFile(path)
2923
 
    elif err.error_verb == 'FileExists':
2924
 
        raise errors.FileExists(err.error_args[0])
2925
 
    elif err.error_verb == 'DirectoryNotEmpty':
2926
 
        raise errors.DirectoryNotEmpty(err.error_args[0])
2927
 
    elif err.error_verb == 'ShortReadvError':
2928
 
        args = err.error_args
2929
 
        raise errors.ShortReadvError(
2930
 
            args[0], int(args[1]), int(args[2]), int(args[3]))
2931
 
    elif err.error_verb in ('UnicodeEncodeError', 'UnicodeDecodeError'):
 
3654
    try:
 
3655
        translator = error_translators.get(err.error_verb)
 
3656
    except KeyError:
 
3657
        pass
 
3658
    else:
 
3659
        raise translator(err, find, get_path)
 
3660
    try:
 
3661
        translator = no_context_error_translators.get(err.error_verb)
 
3662
    except KeyError:
 
3663
        raise errors.UnknownErrorFromSmartServer(err)
 
3664
    else:
 
3665
        raise translator(err)
 
3666
 
 
3667
 
 
3668
error_translators.register('NoSuchRevision',
 
3669
    lambda err, find, get_path: NoSuchRevision(
 
3670
        find('branch'), err.error_args[0]))
 
3671
error_translators.register('nosuchrevision',
 
3672
    lambda err, find, get_path: NoSuchRevision(
 
3673
        find('repository'), err.error_args[0]))
 
3674
 
 
3675
def _translate_nobranch_error(err, find, get_path):
 
3676
    if len(err.error_args) >= 1:
 
3677
        extra = err.error_args[0]
 
3678
    else:
 
3679
        extra = None
 
3680
    return errors.NotBranchError(path=find('bzrdir').root_transport.base,
 
3681
        detail=extra)
 
3682
 
 
3683
error_translators.register('nobranch', _translate_nobranch_error)
 
3684
error_translators.register('norepository',
 
3685
    lambda err, find, get_path: errors.NoRepositoryPresent(
 
3686
        find('bzrdir')))
 
3687
error_translators.register('UnlockableTransport',
 
3688
    lambda err, find, get_path: errors.UnlockableTransport(
 
3689
        find('bzrdir').root_transport))
 
3690
error_translators.register('TokenMismatch',
 
3691
    lambda err, find, get_path: errors.TokenMismatch(
 
3692
        find('token'), '(remote token)'))
 
3693
error_translators.register('Diverged',
 
3694
    lambda err, find, get_path: errors.DivergedBranches(
 
3695
        find('branch'), find('other_branch')))
 
3696
error_translators.register('NotStacked',
 
3697
    lambda err, find, get_path: errors.NotStacked(branch=find('branch')))
 
3698
 
 
3699
def _translate_PermissionDenied(err, find, get_path):
 
3700
    path = get_path()
 
3701
    if len(err.error_args) >= 2:
 
3702
        extra = err.error_args[1]
 
3703
    else:
 
3704
        extra = None
 
3705
    return errors.PermissionDenied(path, extra=extra)
 
3706
 
 
3707
error_translators.register('PermissionDenied', _translate_PermissionDenied)
 
3708
error_translators.register('ReadError',
 
3709
    lambda err, find, get_path: errors.ReadError(get_path()))
 
3710
error_translators.register('NoSuchFile',
 
3711
    lambda err, find, get_path: errors.NoSuchFile(get_path()))
 
3712
no_context_error_translators.register('IncompatibleRepositories',
 
3713
    lambda err: errors.IncompatibleRepositories(
 
3714
        err.error_args[0], err.error_args[1], err.error_args[2]))
 
3715
no_context_error_translators.register('LockContention',
 
3716
    lambda err: errors.LockContention('(remote lock)'))
 
3717
no_context_error_translators.register('LockFailed',
 
3718
    lambda err: errors.LockFailed(err.error_args[0], err.error_args[1]))
 
3719
no_context_error_translators.register('TipChangeRejected',
 
3720
    lambda err: errors.TipChangeRejected(err.error_args[0].decode('utf8')))
 
3721
no_context_error_translators.register('UnstackableBranchFormat',
 
3722
    lambda err: errors.UnstackableBranchFormat(*err.error_args))
 
3723
no_context_error_translators.register('UnstackableRepositoryFormat',
 
3724
    lambda err: errors.UnstackableRepositoryFormat(*err.error_args))
 
3725
no_context_error_translators.register('FileExists',
 
3726
    lambda err: errors.FileExists(err.error_args[0]))
 
3727
no_context_error_translators.register('DirectoryNotEmpty',
 
3728
    lambda err: errors.DirectoryNotEmpty(err.error_args[0]))
 
3729
 
 
3730
def _translate_short_readv_error(err):
 
3731
    args = err.error_args
 
3732
    return errors.ShortReadvError(args[0], int(args[1]), int(args[2]),
 
3733
        int(args[3]))
 
3734
 
 
3735
no_context_error_translators.register('ShortReadvError',
 
3736
    _translate_short_readv_error)
 
3737
 
 
3738
def _translate_unicode_error(err):
2932
3739
        encoding = str(err.error_args[0]) # encoding must always be a string
2933
3740
        val = err.error_args[1]
2934
3741
        start = int(err.error_args[2])
2942
3749
            raise UnicodeDecodeError(encoding, val, start, end, reason)
2943
3750
        elif err.error_verb == 'UnicodeEncodeError':
2944
3751
            raise UnicodeEncodeError(encoding, val, start, end, reason)
2945
 
    elif err.error_verb == 'ReadOnlyError':
2946
 
        raise errors.TransportNotPossible('readonly transport')
2947
 
    raise errors.UnknownErrorFromSmartServer(err)
 
3752
 
 
3753
no_context_error_translators.register('UnicodeEncodeError',
 
3754
    _translate_unicode_error)
 
3755
no_context_error_translators.register('UnicodeDecodeError',
 
3756
    _translate_unicode_error)
 
3757
no_context_error_translators.register('ReadOnlyError',
 
3758
    lambda err: errors.TransportNotPossible('readonly transport'))
 
3759
no_context_error_translators.register('MemoryError',
 
3760
    lambda err: errors.BzrError("remote server out of memory\n"
 
3761
        "Retry non-remotely, or contact the server admin for details."))
 
3762
 
 
3763
no_context_error_translators.register('BzrCheckError',
 
3764
    lambda err: errors.BzrCheckError(msg=err.error_args[0]))
 
3765
 
 
3766
error_translators.register('UnsuspendableWriteGroup',
 
3767
    lambda err, find, get_path: errors.UnsuspendableWriteGroup(
 
3768
        repository=find('repository')))
 
3769
error_translators.register('UnresumableWriteGroup',
 
3770
    lambda err, find, get_path: errors.UnresumableWriteGroup(
 
3771
        repository=find('repository'), write_groups=err.error_args[0],
 
3772
        reason=err.error_args[1]))