← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

(jameinel) (bug #780544) when updating the WT,
 allow it to be done with a fast delta,
 rather than setting the state from scratch. (John A Meinel)

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
30
    repository as _mod_repository,
31
 
    revision,
32
31
    revision as _mod_revision,
33
32
    static_tuple,
34
33
    symbol_versioning,
35
 
)
 
34
    urlutils,
 
35
    versionedfile,
 
36
    vf_repository,
 
37
    )
36
38
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
37
 
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
38
39
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
39
40
from bzrlib.errors import (
40
41
    NoSuchRevision,
42
43
    )
43
44
from bzrlib.lockable_files import LockableFiles
44
45
from bzrlib.smart import client, vfs, repository as smart_repo
45
 
from bzrlib.revision import ensure_null, NULL_REVISION
46
 
from bzrlib.repository import RepositoryWriteLockResult
 
46
from bzrlib.smart.client import _SmartClient
 
47
from bzrlib.revision import NULL_REVISION
 
48
from bzrlib.repository import RepositoryWriteLockResult, _LazyListJoin
47
49
from bzrlib.trace import mutter, note, warning
48
50
 
49
51
 
87
89
    return format
88
90
 
89
91
 
90
 
# Note: RemoteBzrDirFormat is in bzrdir.py
91
 
 
92
 
class RemoteBzrDir(BzrDir, _RpcHelper):
 
92
# Note that RemoteBzrDirProber lives in bzrlib.bzrdir so bzrlib.remote
 
93
# does not have to be imported unless a remote format is involved.
 
94
 
 
95
class RemoteBzrDirFormat(_mod_bzrdir.BzrDirMetaFormat1):
 
96
    """Format representing bzrdirs accessed via a smart server"""
 
97
 
 
98
    supports_workingtrees = False
 
99
 
 
100
    def __init__(self):
 
101
        _mod_bzrdir.BzrDirMetaFormat1.__init__(self)
 
102
        # XXX: It's a bit ugly that the network name is here, because we'd
 
103
        # like to believe that format objects are stateless or at least
 
104
        # immutable,  However, we do at least avoid mutating the name after
 
105
        # it's returned.  See <https://bugs.launchpad.net/bzr/+bug/504102>
 
106
        self._network_name = None
 
107
 
 
108
    def __repr__(self):
 
109
        return "%s(_network_name=%r)" % (self.__class__.__name__,
 
110
            self._network_name)
 
111
 
 
112
    def get_format_description(self):
 
113
        if self._network_name:
 
114
            real_format = controldir.network_format_registry.get(self._network_name)
 
115
            return 'Remote: ' + real_format.get_format_description()
 
116
        return 'bzr remote bzrdir'
 
117
 
 
118
    def get_format_string(self):
 
119
        raise NotImplementedError(self.get_format_string)
 
120
 
 
121
    def network_name(self):
 
122
        if self._network_name:
 
123
            return self._network_name
 
124
        else:
 
125
            raise AssertionError("No network name set.")
 
126
 
 
127
    def initialize_on_transport(self, transport):
 
128
        try:
 
129
            # hand off the request to the smart server
 
130
            client_medium = transport.get_smart_medium()
 
131
        except errors.NoSmartMedium:
 
132
            # TODO: lookup the local format from a server hint.
 
133
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
134
            return local_dir_format.initialize_on_transport(transport)
 
135
        client = _SmartClient(client_medium)
 
136
        path = client.remote_path_from_transport(transport)
 
137
        try:
 
138
            response = client.call('BzrDirFormat.initialize', path)
 
139
        except errors.ErrorFromSmartServer, err:
 
140
            _translate_error(err, path=path)
 
141
        if response[0] != 'ok':
 
142
            raise errors.SmartProtocolError('unexpected response code %s' % (response,))
 
143
        format = RemoteBzrDirFormat()
 
144
        self._supply_sub_formats_to(format)
 
145
        return RemoteBzrDir(transport, format)
 
146
 
 
147
    def parse_NoneTrueFalse(self, arg):
 
148
        if not arg:
 
149
            return None
 
150
        if arg == 'False':
 
151
            return False
 
152
        if arg == 'True':
 
153
            return True
 
154
        raise AssertionError("invalid arg %r" % arg)
 
155
 
 
156
    def _serialize_NoneTrueFalse(self, arg):
 
157
        if arg is False:
 
158
            return 'False'
 
159
        if arg:
 
160
            return 'True'
 
161
        return ''
 
162
 
 
163
    def _serialize_NoneString(self, arg):
 
164
        return arg or ''
 
165
 
 
166
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
 
167
        create_prefix=False, force_new_repo=False, stacked_on=None,
 
168
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
 
169
        shared_repo=False):
 
170
        try:
 
171
            # hand off the request to the smart server
 
172
            client_medium = transport.get_smart_medium()
 
173
        except errors.NoSmartMedium:
 
174
            do_vfs = True
 
175
        else:
 
176
            # Decline to open it if the server doesn't support our required
 
177
            # version (3) so that the VFS-based transport will do it.
 
178
            if client_medium.should_probe():
 
179
                try:
 
180
                    server_version = client_medium.protocol_version()
 
181
                    if server_version != '2':
 
182
                        do_vfs = True
 
183
                    else:
 
184
                        do_vfs = False
 
185
                except errors.SmartProtocolError:
 
186
                    # Apparently there's no usable smart server there, even though
 
187
                    # the medium supports the smart protocol.
 
188
                    do_vfs = True
 
189
            else:
 
190
                do_vfs = False
 
191
        if not do_vfs:
 
192
            client = _SmartClient(client_medium)
 
193
            path = client.remote_path_from_transport(transport)
 
194
            if client_medium._is_remote_before((1, 16)):
 
195
                do_vfs = True
 
196
        if do_vfs:
 
197
            # TODO: lookup the local format from a server hint.
 
198
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
199
            self._supply_sub_formats_to(local_dir_format)
 
200
            return local_dir_format.initialize_on_transport_ex(transport,
 
201
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
202
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
203
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
204
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
205
                vfs_only=True)
 
206
        return self._initialize_on_transport_ex_rpc(client, path, transport,
 
207
            use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
208
            stack_on_pwd, repo_format_name, make_working_trees, shared_repo)
 
209
 
 
210
    def _initialize_on_transport_ex_rpc(self, client, path, transport,
 
211
        use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
212
        stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
 
213
        args = []
 
214
        args.append(self._serialize_NoneTrueFalse(use_existing_dir))
 
215
        args.append(self._serialize_NoneTrueFalse(create_prefix))
 
216
        args.append(self._serialize_NoneTrueFalse(force_new_repo))
 
217
        args.append(self._serialize_NoneString(stacked_on))
 
218
        # stack_on_pwd is often/usually our transport
 
219
        if stack_on_pwd:
 
220
            try:
 
221
                stack_on_pwd = transport.relpath(stack_on_pwd)
 
222
                if not stack_on_pwd:
 
223
                    stack_on_pwd = '.'
 
224
            except errors.PathNotChild:
 
225
                pass
 
226
        args.append(self._serialize_NoneString(stack_on_pwd))
 
227
        args.append(self._serialize_NoneString(repo_format_name))
 
228
        args.append(self._serialize_NoneTrueFalse(make_working_trees))
 
229
        args.append(self._serialize_NoneTrueFalse(shared_repo))
 
230
        request_network_name = self._network_name or \
 
231
            _mod_bzrdir.BzrDirFormat.get_default_format().network_name()
 
232
        try:
 
233
            response = client.call('BzrDirFormat.initialize_ex_1.16',
 
234
                request_network_name, path, *args)
 
235
        except errors.UnknownSmartMethod:
 
236
            client._medium._remember_remote_is_before((1,16))
 
237
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
238
            self._supply_sub_formats_to(local_dir_format)
 
239
            return local_dir_format.initialize_on_transport_ex(transport,
 
240
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
241
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
242
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
243
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
244
                vfs_only=True)
 
245
        except errors.ErrorFromSmartServer, err:
 
246
            _translate_error(err, path=path)
 
247
        repo_path = response[0]
 
248
        bzrdir_name = response[6]
 
249
        require_stacking = response[7]
 
250
        require_stacking = self.parse_NoneTrueFalse(require_stacking)
 
251
        format = RemoteBzrDirFormat()
 
252
        format._network_name = bzrdir_name
 
253
        self._supply_sub_formats_to(format)
 
254
        bzrdir = RemoteBzrDir(transport, format, _client=client)
 
255
        if repo_path:
 
256
            repo_format = response_tuple_to_repo_format(response[1:])
 
257
            if repo_path == '.':
 
258
                repo_path = ''
 
259
            if repo_path:
 
260
                repo_bzrdir_format = RemoteBzrDirFormat()
 
261
                repo_bzrdir_format._network_name = response[5]
 
262
                repo_bzr = RemoteBzrDir(transport.clone(repo_path),
 
263
                    repo_bzrdir_format)
 
264
            else:
 
265
                repo_bzr = bzrdir
 
266
            final_stack = response[8] or None
 
267
            final_stack_pwd = response[9] or None
 
268
            if final_stack_pwd:
 
269
                final_stack_pwd = urlutils.join(
 
270
                    transport.base, final_stack_pwd)
 
271
            remote_repo = RemoteRepository(repo_bzr, repo_format)
 
272
            if len(response) > 10:
 
273
                # Updated server verb that locks remotely.
 
274
                repo_lock_token = response[10] or None
 
275
                remote_repo.lock_write(repo_lock_token, _skip_rpc=True)
 
276
                if repo_lock_token:
 
277
                    remote_repo.dont_leave_lock_in_place()
 
278
            else:
 
279
                remote_repo.lock_write()
 
280
            policy = _mod_bzrdir.UseExistingRepository(remote_repo, final_stack,
 
281
                final_stack_pwd, require_stacking)
 
282
            policy.acquire_repository()
 
283
        else:
 
284
            remote_repo = None
 
285
            policy = None
 
286
        bzrdir._format.set_branch_format(self.get_branch_format())
 
287
        if require_stacking:
 
288
            # The repo has already been created, but we need to make sure that
 
289
            # we'll make a stackable branch.
 
290
            bzrdir._format.require_stacking(_skip_repo=True)
 
291
        return remote_repo, bzrdir, require_stacking, policy
 
292
 
 
293
    def _open(self, transport):
 
294
        return RemoteBzrDir(transport, self)
 
295
 
 
296
    def __eq__(self, other):
 
297
        if not isinstance(other, RemoteBzrDirFormat):
 
298
            return False
 
299
        return self.get_format_description() == other.get_format_description()
 
300
 
 
301
    def __return_repository_format(self):
 
302
        # Always return a RemoteRepositoryFormat object, but if a specific bzr
 
303
        # repository format has been asked for, tell the RemoteRepositoryFormat
 
304
        # that it should use that for init() etc.
 
305
        result = RemoteRepositoryFormat()
 
306
        custom_format = getattr(self, '_repository_format', None)
 
307
        if custom_format:
 
308
            if isinstance(custom_format, RemoteRepositoryFormat):
 
309
                return custom_format
 
310
            else:
 
311
                # We will use the custom format to create repositories over the
 
312
                # wire; expose its details like rich_root_data for code to
 
313
                # query
 
314
                result._custom_format = custom_format
 
315
        return result
 
316
 
 
317
    def get_branch_format(self):
 
318
        result = _mod_bzrdir.BzrDirMetaFormat1.get_branch_format(self)
 
319
        if not isinstance(result, RemoteBranchFormat):
 
320
            new_result = RemoteBranchFormat()
 
321
            new_result._custom_format = result
 
322
            # cache the result
 
323
            self.set_branch_format(new_result)
 
324
            result = new_result
 
325
        return result
 
326
 
 
327
    repository_format = property(__return_repository_format,
 
328
        _mod_bzrdir.BzrDirMetaFormat1._set_repository_format) #.im_func)
 
329
 
 
330
 
 
331
class RemoteBzrDir(_mod_bzrdir.BzrDir, _RpcHelper):
93
332
    """Control directory on a remote server, accessed via bzr:// or similar."""
94
333
 
95
334
    def __init__(self, transport, format, _client=None, _force_probe=False):
98
337
        :param _client: Private parameter for testing. Disables probing and the
99
338
            use of a real bzrdir.
100
339
        """
101
 
        BzrDir.__init__(self, transport, format)
 
340
        _mod_bzrdir.BzrDir.__init__(self, transport, format)
102
341
        # this object holds a delegated bzrdir that uses file-level operations
103
342
        # to talk to the other side
104
343
        self._real_bzrdir = None
164
403
                import traceback
165
404
                warning('VFS BzrDir access triggered\n%s',
166
405
                    ''.join(traceback.format_stack()))
167
 
            self._real_bzrdir = BzrDir.open_from_transport(
 
406
            self._real_bzrdir = _mod_bzrdir.BzrDir.open_from_transport(
168
407
                self.root_transport, _server_formats=False)
169
408
            self._format._network_name = \
170
409
                self._real_bzrdir._format.network_name()
176
415
        # Prevent aliasing problems in the next_open_branch_result cache.
177
416
        # See create_branch for rationale.
178
417
        self._next_open_branch_result = None
179
 
        return BzrDir.break_lock(self)
 
418
        return _mod_bzrdir.BzrDir.break_lock(self)
180
419
 
181
420
    def _vfs_cloning_metadir(self, require_stacking=False):
182
421
        self._ensure_real()
213
452
        if len(branch_info) != 2:
214
453
            raise errors.UnexpectedSmartServerResponse(response)
215
454
        branch_ref, branch_name = branch_info
216
 
        format = bzrdir.network_format_registry.get(control_name)
 
455
        format = controldir.network_format_registry.get(control_name)
217
456
        if repo_name:
218
 
            format.repository_format = repository.network_format_registry.get(
 
457
            format.repository_format = _mod_repository.network_format_registry.get(
219
458
                repo_name)
220
459
        if branch_ref == 'ref':
221
460
            # XXX: we need possible_transports here to avoid reopening the
222
461
            # connection to the referenced location
223
 
            ref_bzrdir = BzrDir.open(branch_name)
 
462
            ref_bzrdir = _mod_bzrdir.BzrDir.open(branch_name)
224
463
            branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
225
464
            format.set_branch_format(branch_format)
226
465
        elif branch_ref == 'branch':
245
484
        self._ensure_real()
246
485
        self._real_bzrdir.destroy_repository()
247
486
 
248
 
    def create_branch(self, name=None):
 
487
    def create_branch(self, name=None, repository=None):
249
488
        # as per meta1 formats - just delegate to the format object which may
250
489
        # be parameterised.
251
490
        real_branch = self._format.get_branch_format().initialize(self,
252
 
            name=name)
 
491
            name=name, repository=repository)
253
492
        if not isinstance(real_branch, RemoteBranch):
254
 
            result = RemoteBranch(self, self.find_repository(), real_branch,
255
 
                                  name=name)
 
493
            if not isinstance(repository, RemoteRepository):
 
494
                raise AssertionError(
 
495
                    'need a RemoteRepository to use with RemoteBranch, got %r'
 
496
                    % (repository,))
 
497
            result = RemoteBranch(self, repository, real_branch, name=name)
256
498
        else:
257
499
            result = real_branch
258
500
        # BzrDir.clone_on_transport() uses the result of create_branch but does
270
512
        self._real_bzrdir.destroy_branch(name=name)
271
513
        self._next_open_branch_result = None
272
514
 
273
 
    def create_workingtree(self, revision_id=None, from_branch=None):
 
515
    def create_workingtree(self, revision_id=None, from_branch=None,
 
516
        accelerator_tree=None, hardlink=False):
274
517
        raise errors.NotLocalUrl(self.transport.base)
275
518
 
276
 
    def find_branch_format(self):
 
519
    def find_branch_format(self, name=None):
277
520
        """Find the branch 'format' for this bzrdir.
278
521
 
279
522
        This might be a synthetic object for e.g. RemoteBranch and SVN.
280
523
        """
281
 
        b = self.open_branch()
 
524
        b = self.open_branch(name=name)
282
525
        return b._format
283
526
 
284
 
    def get_branch_reference(self):
 
527
    def get_branch_reference(self, name=None):
285
528
        """See BzrDir.get_branch_reference()."""
 
529
        if name is not None:
 
530
            # XXX JRV20100304: Support opening colocated branches
 
531
            raise errors.NoColocatedBranchSupport(self)
286
532
        response = self._get_branch_reference()
287
533
        if response[0] == 'ref':
288
534
            return response[1]
319
565
            raise errors.UnexpectedSmartServerResponse(response)
320
566
        return response
321
567
 
322
 
    def _get_tree_branch(self):
 
568
    def _get_tree_branch(self, name=None):
323
569
        """See BzrDir._get_tree_branch()."""
324
 
        return None, self.open_branch()
 
570
        return None, self.open_branch(name=name)
325
571
 
326
572
    def open_branch(self, name=None, unsupported=False,
327
573
                    ignore_fallbacks=False):
442
688
        """Upgrading of remote bzrdirs is not supported yet."""
443
689
        return False
444
690
 
445
 
    def needs_format_conversion(self, format=None):
 
691
    def needs_format_conversion(self, format):
446
692
        """Upgrading of remote bzrdirs is not supported yet."""
447
 
        if format is None:
448
 
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
449
 
                % 'needs_format_conversion(format=None)')
450
693
        return False
451
694
 
452
695
    def clone(self, url, revision_id=None, force_new_repo=False,
459
702
        return RemoteBzrDirConfig(self)
460
703
 
461
704
 
462
 
class RemoteRepositoryFormat(repository.RepositoryFormat):
 
705
class RemoteRepositoryFormat(vf_repository.VersionedFileRepositoryFormat):
463
706
    """Format for repositories accessed over a _SmartClient.
464
707
 
465
708
    Instances of this repository are represented by RemoteRepository
480
723
    """
481
724
 
482
725
    _matchingbzrdir = RemoteBzrDirFormat()
 
726
    supports_full_versioned_files = True
 
727
    supports_leaving_lock = True
483
728
 
484
729
    def __init__(self):
485
 
        repository.RepositoryFormat.__init__(self)
 
730
        _mod_repository.RepositoryFormat.__init__(self)
486
731
        self._custom_format = None
487
732
        self._network_name = None
488
733
        self._creating_bzrdir = None
 
734
        self._revision_graph_can_have_wrong_parents = None
489
735
        self._supports_chks = None
490
736
        self._supports_external_lookups = None
491
737
        self._supports_tree_reference = None
 
738
        self._supports_funky_characters = None
492
739
        self._rich_root_data = None
493
740
 
494
741
    def __repr__(self):
523
770
        return self._supports_external_lookups
524
771
 
525
772
    @property
 
773
    def supports_funky_characters(self):
 
774
        if self._supports_funky_characters is None:
 
775
            self._ensure_real()
 
776
            self._supports_funky_characters = \
 
777
                self._custom_format.supports_funky_characters
 
778
        return self._supports_funky_characters
 
779
 
 
780
    @property
526
781
    def supports_tree_reference(self):
527
782
        if self._supports_tree_reference is None:
528
783
            self._ensure_real()
530
785
                self._custom_format.supports_tree_reference
531
786
        return self._supports_tree_reference
532
787
 
 
788
    @property
 
789
    def revision_graph_can_have_wrong_parents(self):
 
790
        if self._revision_graph_can_have_wrong_parents is None:
 
791
            self._ensure_real()
 
792
            self._revision_graph_can_have_wrong_parents = \
 
793
                self._custom_format.revision_graph_can_have_wrong_parents
 
794
        return self._revision_graph_can_have_wrong_parents
 
795
 
533
796
    def _vfs_initialize(self, a_bzrdir, shared):
534
797
        """Helper for common code in initialize."""
535
798
        if self._custom_format:
570
833
            network_name = self._network_name
571
834
        else:
572
835
            # Select the current bzrlib default and ask for that.
573
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
836
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
574
837
            reference_format = reference_bzrdir_format.repository_format
575
838
            network_name = reference_format.network_name()
576
839
        # 2) try direct creation via RPC
602
865
 
603
866
    def _ensure_real(self):
604
867
        if self._custom_format is None:
605
 
            self._custom_format = repository.network_format_registry.get(
 
868
            self._custom_format = _mod_repository.network_format_registry.get(
606
869
                self._network_name)
607
870
 
608
871
    @property
645
908
 
646
909
 
647
910
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
648
 
    bzrdir.ControlComponent):
 
911
    controldir.ControlComponent):
649
912
    """Repository accessed over rpc.
650
913
 
651
914
    For the moment most operations are performed using local transport-backed
704
967
        # transport, but I'm not sure it's worth making this method
705
968
        # optional -- mbp 2010-04-21
706
969
        return self.bzrdir.get_repository_transport(None)
707
 
        
 
970
 
708
971
    def __str__(self):
709
972
        return "%s(%s)" % (self.__class__.__name__, self.base)
710
973
 
818
1081
    def find_text_key_references(self):
819
1082
        """Find the text key references within the repository.
820
1083
 
821
 
        :return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
822
 
        revision_ids. Each altered file-ids has the exact revision_ids that
823
 
        altered it listed explicitly.
824
1084
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
825
1085
            to whether they were referred to by the inventory of the
826
1086
            revision_id that they contain. The inventory texts from all present
844
1104
        """Private method for using with old (< 1.2) servers to fallback."""
845
1105
        if revision_id is None:
846
1106
            revision_id = ''
847
 
        elif revision.is_null(revision_id):
 
1107
        elif _mod_revision.is_null(revision_id):
848
1108
            return {}
849
1109
 
850
1110
        path = self.bzrdir._path_for_remote_call(self._client)
874
1134
        return RemoteStreamSource(self, to_format)
875
1135
 
876
1136
    @needs_read_lock
 
1137
    def get_file_graph(self):
 
1138
        return graph.Graph(self.texts)
 
1139
 
 
1140
    @needs_read_lock
877
1141
    def has_revision(self, revision_id):
878
1142
        """True if this repository has a copy of the revision."""
879
1143
        # Copy of bzrlib.repository.Repository.has_revision
896
1160
    def _has_same_fallbacks(self, other_repo):
897
1161
        """Returns true if the repositories have the same fallbacks."""
898
1162
        # XXX: copied from Repository; it should be unified into a base class
899
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
 
1163
        # <https://bugs.launchpad.net/bzr/+bug/401622>
900
1164
        my_fb = self._fallback_repositories
901
1165
        other_fb = other_repo._fallback_repositories
902
1166
        if len(my_fb) != len(other_fb):
931
1195
        """See Repository.gather_stats()."""
932
1196
        path = self.bzrdir._path_for_remote_call(self._client)
933
1197
        # revid can be None to indicate no revisions, not just NULL_REVISION
934
 
        if revid is None or revision.is_null(revid):
 
1198
        if revid is None or _mod_revision.is_null(revid):
935
1199
            fmt_revid = ''
936
1200
        else:
937
1201
            fmt_revid = revid
1000
1264
    def lock_read(self):
1001
1265
        """Lock the repository for read operations.
1002
1266
 
1003
 
        :return: An object with an unlock method which will release the lock
1004
 
            obtained.
 
1267
        :return: A bzrlib.lock.LogicalLockResult.
1005
1268
        """
1006
1269
        # wrong eventually - want a local lock cache context
1007
1270
        if not self._lock_mode:
1015
1278
                repo.lock_read()
1016
1279
        else:
1017
1280
            self._lock_count += 1
1018
 
        return self
 
1281
        return lock.LogicalLockResult(self.unlock)
1019
1282
 
1020
1283
    def _remote_lock_write(self, token):
1021
1284
        path = self.bzrdir._path_for_remote_call(self._client)
1221
1484
 
1222
1485
    def get_commit_builder(self, branch, parents, config, timestamp=None,
1223
1486
                           timezone=None, committer=None, revprops=None,
1224
 
                           revision_id=None):
 
1487
                           revision_id=None, lossy=False):
1225
1488
        # FIXME: It ought to be possible to call this without immediately
1226
1489
        # triggering _ensure_real.  For now it's the easiest thing to do.
1227
1490
        self._ensure_real()
1228
1491
        real_repo = self._real_repository
1229
1492
        builder = real_repo.get_commit_builder(branch, parents,
1230
1493
                config, timestamp=timestamp, timezone=timezone,
1231
 
                committer=committer, revprops=revprops, revision_id=revision_id)
 
1494
                committer=committer, revprops=revprops,
 
1495
                revision_id=revision_id, lossy=lossy)
1232
1496
        return builder
1233
1497
 
1234
1498
    def add_fallback_repository(self, repository):
1313
1577
        return self._real_repository.make_working_trees()
1314
1578
 
1315
1579
    def refresh_data(self):
1316
 
        """Re-read any data needed to to synchronise with disk.
 
1580
        """Re-read any data needed to synchronise with disk.
1317
1581
 
1318
1582
        This method is intended to be called after another repository instance
1319
1583
        (such as one used by a smart server) has inserted data into the
1320
 
        repository. It may not be called during a write group, but may be
1321
 
        called at any other time.
 
1584
        repository. On all repositories this will work outside of write groups.
 
1585
        Some repository formats (pack and newer for bzrlib native formats)
 
1586
        support refresh_data inside write groups. If called inside a write
 
1587
        group on a repository that does not support refreshing in a write group
 
1588
        IsInWriteGroupError will be raised.
1322
1589
        """
1323
 
        if self.is_in_write_group():
1324
 
            raise errors.InternalBzrError(
1325
 
                "May not refresh_data while in a write group.")
1326
1590
        if self._real_repository is not None:
1327
1591
            self._real_repository.refresh_data()
1328
1592
 
1340
1604
        return result
1341
1605
 
1342
1606
    @needs_read_lock
1343
 
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
 
1607
    def search_missing_revision_ids(self, other,
 
1608
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
 
1609
            find_ghosts=True, revision_ids=None, if_present_ids=None):
1344
1610
        """Return the revision ids that other has that this does not.
1345
1611
 
1346
1612
        These are returned in topological order.
1347
1613
 
1348
1614
        revision_id: only return revision ids included by revision_id.
1349
1615
        """
1350
 
        return repository.InterRepository.get(
1351
 
            other, self).search_missing_revision_ids(revision_id, find_ghosts)
 
1616
        if symbol_versioning.deprecated_passed(revision_id):
 
1617
            symbol_versioning.warn(
 
1618
                'search_missing_revision_ids(revision_id=...) was '
 
1619
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
 
1620
                DeprecationWarning, stacklevel=2)
 
1621
            if revision_ids is not None:
 
1622
                raise AssertionError(
 
1623
                    'revision_ids is mutually exclusive with revision_id')
 
1624
            if revision_id is not None:
 
1625
                revision_ids = [revision_id]
 
1626
        inter_repo = _mod_repository.InterRepository.get(other, self)
 
1627
        return inter_repo.search_missing_revision_ids(
 
1628
            find_ghosts=find_ghosts, revision_ids=revision_ids,
 
1629
            if_present_ids=if_present_ids)
1352
1630
 
1353
 
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
 
1631
    def fetch(self, source, revision_id=None, find_ghosts=False,
1354
1632
            fetch_spec=None):
1355
1633
        # No base implementation to use as RemoteRepository is not a subclass
1356
1634
        # of Repository; so this is a copy of Repository.fetch().
1367
1645
            # check that last_revision is in 'from' and then return a
1368
1646
            # no-operation.
1369
1647
            if (revision_id is not None and
1370
 
                not revision.is_null(revision_id)):
 
1648
                not _mod_revision.is_null(revision_id)):
1371
1649
                self.get_revision(revision_id)
1372
1650
            return 0, []
1373
1651
        # if there is no specific appropriate InterRepository, this will get
1374
1652
        # the InterRepository base class, which raises an
1375
1653
        # IncompatibleRepositories when asked to fetch.
1376
 
        inter = repository.InterRepository.get(source, self)
1377
 
        return inter.fetch(revision_id=revision_id, pb=pb,
 
1654
        inter = _mod_repository.InterRepository.get(source, self)
 
1655
        return inter.fetch(revision_id=revision_id,
1378
1656
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1379
1657
 
1380
1658
    def create_bundle(self, target, base, fileobj, format=None):
1604
1882
            tmpdir = osutils.mkdtemp()
1605
1883
            try:
1606
1884
                _extract_tar(tar, tmpdir)
1607
 
                tmp_bzrdir = BzrDir.open(tmpdir)
 
1885
                tmp_bzrdir = _mod_bzrdir.BzrDir.open(tmpdir)
1608
1886
                tmp_repo = tmp_bzrdir.open_repository()
1609
1887
                tmp_repo.copy_content_into(destination, revision_id)
1610
1888
            finally:
1721
1999
        return self._real_repository.item_keys_introduced_by(revision_ids,
1722
2000
            _files_pb=_files_pb)
1723
2001
 
1724
 
    def revision_graph_can_have_wrong_parents(self):
1725
 
        # The answer depends on the remote repo format.
1726
 
        self._ensure_real()
1727
 
        return self._real_repository.revision_graph_can_have_wrong_parents()
1728
 
 
1729
2002
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
1730
2003
        self._ensure_real()
1731
2004
        return self._real_repository._find_inconsistent_revision_parents(
1739
2012
        providers = [self._unstacked_provider]
1740
2013
        if other is not None:
1741
2014
            providers.insert(0, other)
1742
 
        providers.extend(r._make_parents_provider() for r in
1743
 
                         self._fallback_repositories)
1744
 
        return graph.StackedParentsProvider(providers)
 
2015
        return graph.StackedParentsProvider(_LazyListJoin(
 
2016
            providers, self._fallback_repositories))
1745
2017
 
1746
2018
    def _serialise_search_recipe(self, recipe):
1747
2019
        """Serialise a graph search recipe.
1755
2027
        return '\n'.join((start_keys, stop_keys, count))
1756
2028
 
1757
2029
    def _serialise_search_result(self, search_result):
1758
 
        if isinstance(search_result, graph.PendingAncestryResult):
1759
 
            parts = ['ancestry-of']
1760
 
            parts.extend(search_result.heads)
1761
 
        else:
1762
 
            recipe = search_result.get_recipe()
1763
 
            parts = [recipe[0], self._serialise_search_recipe(recipe)]
 
2030
        parts = search_result.get_network_struct()
1764
2031
        return '\n'.join(parts)
1765
2032
 
1766
2033
    def autopack(self):
1776
2043
            raise errors.UnexpectedSmartServerResponse(response)
1777
2044
 
1778
2045
 
1779
 
class RemoteStreamSink(repository.StreamSink):
 
2046
class RemoteStreamSink(vf_repository.StreamSink):
1780
2047
 
1781
2048
    def _insert_real(self, stream, src_format, resume_tokens):
1782
2049
        self.target_repo._ensure_real()
1883
2150
        self._last_substream and self._last_stream so that the stream can be
1884
2151
        resumed by _resume_stream_with_vfs.
1885
2152
        """
1886
 
                    
 
2153
 
1887
2154
        stream_iter = iter(stream)
1888
2155
        for substream_kind, substream in stream_iter:
1889
2156
            if substream_kind == 'inventory-deltas':
1892
2159
                return
1893
2160
            else:
1894
2161
                yield substream_kind, substream
1895
 
            
1896
 
 
1897
 
class RemoteStreamSource(repository.StreamSource):
 
2162
 
 
2163
 
 
2164
class RemoteStreamSource(vf_repository.StreamSource):
1898
2165
    """Stream data from a remote server."""
1899
2166
 
1900
2167
    def get_stream(self, search):
1960
2227
        candidate_verbs = [
1961
2228
            ('Repository.get_stream_1.19', (1, 19)),
1962
2229
            ('Repository.get_stream', (1, 13))]
 
2230
 
1963
2231
        found_verb = False
1964
2232
        for verb, version in candidate_verbs:
1965
2233
            if medium._is_remote_before(version):
1969
2237
                    verb, args, search_bytes)
1970
2238
            except errors.UnknownSmartMethod:
1971
2239
                medium._remember_remote_is_before(version)
 
2240
            except errors.UnknownErrorFromSmartServer, e:
 
2241
                if isinstance(search, graph.EverythingResult):
 
2242
                    error_verb = e.error_from_smart_server.error_verb
 
2243
                    if error_verb == 'BadSearch':
 
2244
                        # Pre-2.4 servers don't support this sort of search.
 
2245
                        # XXX: perhaps falling back to VFS on BadSearch is a
 
2246
                        # good idea in general?  It might provide a little bit
 
2247
                        # of protection against client-side bugs.
 
2248
                        medium._remember_remote_is_before((2, 4))
 
2249
                        break
 
2250
                raise
1972
2251
            else:
1973
2252
                response_tuple, response_handler = response
1974
2253
                found_verb = True
1978
2257
        if response_tuple[0] != 'ok':
1979
2258
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1980
2259
        byte_stream = response_handler.read_streamed_body()
1981
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
 
2260
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
 
2261
            self._record_counter)
1982
2262
        if src_format.network_name() != repo._format.network_name():
1983
2263
            raise AssertionError(
1984
2264
                "Mismatched RemoteRepository and stream src %r, %r" % (
2088
2368
                                  name=name)
2089
2369
        return result
2090
2370
 
2091
 
    def initialize(self, a_bzrdir, name=None):
 
2371
    def initialize(self, a_bzrdir, name=None, repository=None):
2092
2372
        # 1) get the network name to use.
2093
2373
        if self._custom_format:
2094
2374
            network_name = self._custom_format.network_name()
2095
2375
        else:
2096
2376
            # Select the current bzrlib default and ask for that.
2097
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
2377
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
2098
2378
            reference_format = reference_bzrdir_format.get_branch_format()
2099
2379
            self._custom_format = reference_format
2100
2380
            network_name = reference_format.network_name()
2122
2402
        # Turn the response into a RemoteRepository object.
2123
2403
        format = RemoteBranchFormat(network_name=response[1])
2124
2404
        repo_format = response_tuple_to_repo_format(response[3:])
2125
 
        if response[2] == '':
2126
 
            repo_bzrdir = a_bzrdir
 
2405
        repo_path = response[2]
 
2406
        if repository is not None:
 
2407
            remote_repo_url = urlutils.join(a_bzrdir.user_url, repo_path)
 
2408
            url_diff = urlutils.relative_url(repository.user_url,
 
2409
                    remote_repo_url)
 
2410
            if url_diff != '.':
 
2411
                raise AssertionError(
 
2412
                    'repository.user_url %r does not match URL from server '
 
2413
                    'response (%r + %r)'
 
2414
                    % (repository.user_url, a_bzrdir.user_url, repo_path))
 
2415
            remote_repo = repository
2127
2416
        else:
2128
 
            repo_bzrdir = RemoteBzrDir(
2129
 
                a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
2130
 
                a_bzrdir._client)
2131
 
        remote_repo = RemoteRepository(repo_bzrdir, repo_format)
 
2417
            if repo_path == '':
 
2418
                repo_bzrdir = a_bzrdir
 
2419
            else:
 
2420
                repo_bzrdir = RemoteBzrDir(
 
2421
                    a_bzrdir.root_transport.clone(repo_path), a_bzrdir._format,
 
2422
                    a_bzrdir._client)
 
2423
            remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2132
2424
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2133
2425
            format=format, setup_stacking=False, name=name)
2134
2426
        # XXX: We know this is a new branch, so it must have revno 0, revid
2155
2447
        self._ensure_real()
2156
2448
        return self._custom_format.supports_set_append_revisions_only()
2157
2449
 
 
2450
    def _use_default_local_heads_to_fetch(self):
 
2451
        # If the branch format is a metadir format *and* its heads_to_fetch
 
2452
        # implementation is not overridden vs the base class, we can use the
 
2453
        # base class logic rather than use the heads_to_fetch RPC.  This is
 
2454
        # usually cheaper in terms of net round trips, as the last-revision and
 
2455
        # tags info fetched is cached and would be fetched anyway.
 
2456
        self._ensure_real()
 
2457
        if isinstance(self._custom_format, branch.BranchFormatMetadir):
 
2458
            branch_class = self._custom_format._branch_class()
 
2459
            heads_to_fetch_impl = branch_class.heads_to_fetch.im_func
 
2460
            if heads_to_fetch_impl is branch.Branch.heads_to_fetch.im_func:
 
2461
                return True
 
2462
        return False
2158
2463
 
2159
2464
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
2160
2465
    """Branch stored on a server accessed by HPSS RPC.
2359
2664
            self._is_stacked = False
2360
2665
        else:
2361
2666
            self._is_stacked = True
2362
 
        
 
2667
 
2363
2668
    def _vfs_get_tags_bytes(self):
2364
2669
        self._ensure_real()
2365
2670
        return self._real_branch._get_tags_bytes()
2366
2671
 
 
2672
    @needs_read_lock
2367
2673
    def _get_tags_bytes(self):
 
2674
        if self._tags_bytes is None:
 
2675
            self._tags_bytes = self._get_tags_bytes_via_hpss()
 
2676
        return self._tags_bytes
 
2677
 
 
2678
    def _get_tags_bytes_via_hpss(self):
2368
2679
        medium = self._client._medium
2369
2680
        if medium._is_remote_before((1, 13)):
2370
2681
            return self._vfs_get_tags_bytes()
2380
2691
        return self._real_branch._set_tags_bytes(bytes)
2381
2692
 
2382
2693
    def _set_tags_bytes(self, bytes):
 
2694
        if self.is_locked():
 
2695
            self._tags_bytes = bytes
2383
2696
        medium = self._client._medium
2384
2697
        if medium._is_remote_before((1, 18)):
2385
2698
            self._vfs_set_tags_bytes(bytes)
2396
2709
    def lock_read(self):
2397
2710
        """Lock the branch for read operations.
2398
2711
 
2399
 
        :return: An object with an unlock method which will release the lock
2400
 
            obtained.
 
2712
        :return: A bzrlib.lock.LogicalLockResult.
2401
2713
        """
2402
2714
        self.repository.lock_read()
2403
2715
        if not self._lock_mode:
2408
2720
                self._real_branch.lock_read()
2409
2721
        else:
2410
2722
            self._lock_count += 1
2411
 
        return self
 
2723
        return lock.LogicalLockResult(self.unlock)
2412
2724
 
2413
2725
    def _remote_lock_write(self, token):
2414
2726
        if token is None:
2418
2730
            repo_token = self.repository.lock_write().repository_token
2419
2731
            self.repository.unlock()
2420
2732
        err_context = {'token': token}
2421
 
        response = self._call(
2422
 
            'Branch.lock_write', self._remote_path(), branch_token,
2423
 
            repo_token or '', **err_context)
 
2733
        try:
 
2734
            response = self._call(
 
2735
                'Branch.lock_write', self._remote_path(), branch_token,
 
2736
                repo_token or '', **err_context)
 
2737
        except errors.LockContention, e:
 
2738
            # The LockContention from the server doesn't have any
 
2739
            # information about the lock_url. We re-raise LockContention
 
2740
            # with valid lock_url.
 
2741
            raise errors.LockContention('(remote lock)',
 
2742
                self.repository.base.split('.bzr/')[0])
2424
2743
        if response[0] != 'ok':
2425
2744
            raise errors.UnexpectedSmartServerResponse(response)
2426
2745
        ok, branch_token, repo_token = response
2447
2766
            self._lock_mode = 'w'
2448
2767
            self._lock_count = 1
2449
2768
        elif self._lock_mode == 'r':
2450
 
            raise errors.ReadOnlyTransaction
 
2769
            raise errors.ReadOnlyError(self)
2451
2770
        else:
2452
2771
            if token is not None:
2453
2772
                # A token was given to lock_write, and we're relocking, so
2533
2852
            missing_parent = parent_map[missing_parent]
2534
2853
        raise errors.RevisionNotPresent(missing_parent, self.repository)
2535
2854
 
2536
 
    def _last_revision_info(self):
 
2855
    def _read_last_revision_info(self):
2537
2856
        response = self._call('Branch.last_revision_info', self._remote_path())
2538
2857
        if response[0] != 'ok':
2539
2858
            raise SmartProtocolError('unexpected response code %s' % (response,))
2602
2921
            raise errors.UnexpectedSmartServerResponse(response)
2603
2922
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2604
2923
 
 
2924
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2605
2925
    @needs_write_lock
2606
2926
    def set_revision_history(self, rev_history):
 
2927
        """See Branch.set_revision_history."""
 
2928
        self._set_revision_history(rev_history)
 
2929
 
 
2930
    @needs_write_lock
 
2931
    def _set_revision_history(self, rev_history):
2607
2932
        # Send just the tip revision of the history; the server will generate
2608
2933
        # the full history from that.  If the revision doesn't exist in this
2609
2934
        # branch, NoSuchRevision will be raised.
2667
2992
            _override_hook_target=self, **kwargs)
2668
2993
 
2669
2994
    @needs_read_lock
2670
 
    def push(self, target, overwrite=False, stop_revision=None):
 
2995
    def push(self, target, overwrite=False, stop_revision=None, lossy=False):
2671
2996
        self._ensure_real()
2672
2997
        return self._real_branch.push(
2673
 
            target, overwrite=overwrite, stop_revision=stop_revision,
 
2998
            target, overwrite=overwrite, stop_revision=stop_revision, lossy=lossy,
2674
2999
            _override_hook_source_branch=self)
2675
3000
 
2676
3001
    def is_locked(self):
2686
3011
        # XXX: These should be returned by the set_last_revision_info verb
2687
3012
        old_revno, old_revid = self.last_revision_info()
2688
3013
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
2689
 
        revision_id = ensure_null(revision_id)
 
3014
        if not revision_id or not isinstance(revision_id, basestring):
 
3015
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2690
3016
        try:
2691
3017
            response = self._call('Branch.set_last_revision_info',
2692
3018
                self._remote_path(), self._lock_token, self._repo_lock_token,
2721
3047
            except errors.UnknownSmartMethod:
2722
3048
                medium._remember_remote_is_before((1, 6))
2723
3049
        self._clear_cached_state_of_remote_branch_only()
2724
 
        self.set_revision_history(self._lefthand_history(revision_id,
 
3050
        self._set_revision_history(self._lefthand_history(revision_id,
2725
3051
            last_rev=last_rev,other_branch=other_branch))
2726
3052
 
2727
3053
    def set_push_location(self, location):
2728
3054
        self._ensure_real()
2729
3055
        return self._real_branch.set_push_location(location)
2730
3056
 
 
3057
    def heads_to_fetch(self):
 
3058
        if self._format._use_default_local_heads_to_fetch():
 
3059
            # We recognise this format, and its heads-to-fetch implementation
 
3060
            # is the default one (tip + tags).  In this case it's cheaper to
 
3061
            # just use the default implementation rather than a special RPC as
 
3062
            # the tip and tags data is cached.
 
3063
            return branch.Branch.heads_to_fetch(self)
 
3064
        medium = self._client._medium
 
3065
        if medium._is_remote_before((2, 4)):
 
3066
            return self._vfs_heads_to_fetch()
 
3067
        try:
 
3068
            return self._rpc_heads_to_fetch()
 
3069
        except errors.UnknownSmartMethod:
 
3070
            medium._remember_remote_is_before((2, 4))
 
3071
            return self._vfs_heads_to_fetch()
 
3072
 
 
3073
    def _rpc_heads_to_fetch(self):
 
3074
        response = self._call('Branch.heads_to_fetch', self._remote_path())
 
3075
        if len(response) != 2:
 
3076
            raise errors.UnexpectedSmartServerResponse(response)
 
3077
        must_fetch, if_present_fetch = response
 
3078
        return set(must_fetch), set(if_present_fetch)
 
3079
 
 
3080
    def _vfs_heads_to_fetch(self):
 
3081
        self._ensure_real()
 
3082
        return self._real_branch.heads_to_fetch()
 
3083
 
2731
3084
 
2732
3085
class RemoteConfig(object):
2733
3086
    """A Config that reads and writes from smart verbs.
2787
3140
        medium = self._branch._client._medium
2788
3141
        if medium._is_remote_before((1, 14)):
2789
3142
            return self._vfs_set_option(value, name, section)
 
3143
        if isinstance(value, dict):
 
3144
            if medium._is_remote_before((2, 2)):
 
3145
                return self._vfs_set_option(value, name, section)
 
3146
            return self._set_config_option_dict(value, name, section)
 
3147
        else:
 
3148
            return self._set_config_option(value, name, section)
 
3149
 
 
3150
    def _set_config_option(self, value, name, section):
2790
3151
        try:
2791
3152
            path = self._branch._remote_path()
2792
3153
            response = self._branch._client.call('Branch.set_config_option',
2793
3154
                path, self._branch._lock_token, self._branch._repo_lock_token,
2794
3155
                value.encode('utf8'), name, section or '')
2795
3156
        except errors.UnknownSmartMethod:
 
3157
            medium = self._branch._client._medium
2796
3158
            medium._remember_remote_is_before((1, 14))
2797
3159
            return self._vfs_set_option(value, name, section)
2798
3160
        if response != ():
2799
3161
            raise errors.UnexpectedSmartServerResponse(response)
2800
3162
 
 
3163
    def _serialize_option_dict(self, option_dict):
 
3164
        utf8_dict = {}
 
3165
        for key, value in option_dict.items():
 
3166
            if isinstance(key, unicode):
 
3167
                key = key.encode('utf8')
 
3168
            if isinstance(value, unicode):
 
3169
                value = value.encode('utf8')
 
3170
            utf8_dict[key] = value
 
3171
        return bencode.bencode(utf8_dict)
 
3172
 
 
3173
    def _set_config_option_dict(self, value, name, section):
 
3174
        try:
 
3175
            path = self._branch._remote_path()
 
3176
            serialised_dict = self._serialize_option_dict(value)
 
3177
            response = self._branch._client.call(
 
3178
                'Branch.set_config_option_dict',
 
3179
                path, self._branch._lock_token, self._branch._repo_lock_token,
 
3180
                serialised_dict, name, section or '')
 
3181
        except errors.UnknownSmartMethod:
 
3182
            medium = self._branch._client._medium
 
3183
            medium._remember_remote_is_before((2, 2))
 
3184
            return self._vfs_set_option(value, name, section)
 
3185
        if response != ():
 
3186
            raise errors.UnexpectedSmartServerResponse(response)
 
3187
 
2801
3188
    def _real_object(self):
2802
3189
        self._branch._ensure_real()
2803
3190
        return self._branch._real_branch
2886
3273
                    'Missing key %r in context %r', key_err.args[0], context)
2887
3274
                raise err
2888
3275
 
2889
 
    if err.error_verb == 'IncompatibleRepositories':
2890
 
        raise errors.IncompatibleRepositories(err.error_args[0],
2891
 
            err.error_args[1], err.error_args[2])
2892
 
    elif err.error_verb == 'NoSuchRevision':
 
3276
    if err.error_verb == 'NoSuchRevision':
2893
3277
        raise NoSuchRevision(find('branch'), err.error_args[0])
2894
3278
    elif err.error_verb == 'nosuchrevision':
2895
3279
        raise NoSuchRevision(find('repository'), err.error_args[0])
2902
3286
            detail=extra)
2903
3287
    elif err.error_verb == 'norepository':
2904
3288
        raise errors.NoRepositoryPresent(find('bzrdir'))
2905
 
    elif err.error_verb == 'LockContention':
2906
 
        raise errors.LockContention('(remote lock)')
2907
3289
    elif err.error_verb == 'UnlockableTransport':
2908
3290
        raise errors.UnlockableTransport(find('bzrdir').root_transport)
2909
 
    elif err.error_verb == 'LockFailed':
2910
 
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
2911
3291
    elif err.error_verb == 'TokenMismatch':
2912
3292
        raise errors.TokenMismatch(find('token'), '(remote token)')
2913
3293
    elif err.error_verb == 'Diverged':
2914
3294
        raise errors.DivergedBranches(find('branch'), find('other_branch'))
2915
 
    elif err.error_verb == 'TipChangeRejected':
2916
 
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
2917
 
    elif err.error_verb == 'UnstackableBranchFormat':
2918
 
        raise errors.UnstackableBranchFormat(*err.error_args)
2919
 
    elif err.error_verb == 'UnstackableRepositoryFormat':
2920
 
        raise errors.UnstackableRepositoryFormat(*err.error_args)
2921
3295
    elif err.error_verb == 'NotStacked':
2922
3296
        raise errors.NotStacked(branch=find('branch'))
2923
3297
    elif err.error_verb == 'PermissionDenied':
2933
3307
    elif err.error_verb == 'NoSuchFile':
2934
3308
        path = get_path()
2935
3309
        raise errors.NoSuchFile(path)
 
3310
    _translate_error_without_context(err)
 
3311
 
 
3312
 
 
3313
def _translate_error_without_context(err):
 
3314
    """Translate any ErrorFromSmartServer values that don't require context"""
 
3315
    if err.error_verb == 'IncompatibleRepositories':
 
3316
        raise errors.IncompatibleRepositories(err.error_args[0],
 
3317
            err.error_args[1], err.error_args[2])
 
3318
    elif err.error_verb == 'LockContention':
 
3319
        raise errors.LockContention('(remote lock)')
 
3320
    elif err.error_verb == 'LockFailed':
 
3321
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
 
3322
    elif err.error_verb == 'TipChangeRejected':
 
3323
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
 
3324
    elif err.error_verb == 'UnstackableBranchFormat':
 
3325
        raise errors.UnstackableBranchFormat(*err.error_args)
 
3326
    elif err.error_verb == 'UnstackableRepositoryFormat':
 
3327
        raise errors.UnstackableRepositoryFormat(*err.error_args)
2936
3328
    elif err.error_verb == 'FileExists':
2937
3329
        raise errors.FileExists(err.error_args[0])
2938
3330
    elif err.error_verb == 'DirectoryNotEmpty':
2957
3349
            raise UnicodeEncodeError(encoding, val, start, end, reason)
2958
3350
    elif err.error_verb == 'ReadOnlyError':
2959
3351
        raise errors.TransportNotPossible('readonly transport')
 
3352
    elif err.error_verb == 'MemoryError':
 
3353
        raise errors.BzrError("remote server out of memory\n"
 
3354
            "Retry non-remotely, or contact the server admin for details.")
2960
3355
    raise errors.UnknownErrorFromSmartServer(err)