← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: Jelmer Vernooij
  • Date: 2011-06-16 16:06:33 UTC
  • mto: This revision was merged to the branch mainline in revision 5979.
  • Revision ID: jelmer@samba.org-20110616160633-o7gytmtrm37jr89p
Fix import

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
 
)
36
 
from bzrlib.branch import BranchReferenceFormat
37
 
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
 
34
    urlutils,
 
35
    versionedfile,
 
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,
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.smart.client import _SmartClient
 
47
from bzrlib.revision import NULL_REVISION
 
48
from bzrlib.repository import RepositoryWriteLockResult, _LazyListJoin
46
49
from bzrlib.trace import mutter, note, warning
47
50
 
48
51
 
86
89
    return format
87
90
 
88
91
 
89
 
# Note: RemoteBzrDirFormat is in bzrdir.py
90
 
 
91
 
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):
92
332
    """Control directory on a remote server, accessed via bzr:// or similar."""
93
333
 
94
334
    def __init__(self, transport, format, _client=None, _force_probe=False):
97
337
        :param _client: Private parameter for testing. Disables probing and the
98
338
            use of a real bzrdir.
99
339
        """
100
 
        BzrDir.__init__(self, transport, format)
 
340
        _mod_bzrdir.BzrDir.__init__(self, transport, format)
101
341
        # this object holds a delegated bzrdir that uses file-level operations
102
342
        # to talk to the other side
103
343
        self._real_bzrdir = None
163
403
                import traceback
164
404
                warning('VFS BzrDir access triggered\n%s',
165
405
                    ''.join(traceback.format_stack()))
166
 
            self._real_bzrdir = BzrDir.open_from_transport(
 
406
            self._real_bzrdir = _mod_bzrdir.BzrDir.open_from_transport(
167
407
                self.root_transport, _server_formats=False)
168
408
            self._format._network_name = \
169
409
                self._real_bzrdir._format.network_name()
175
415
        # Prevent aliasing problems in the next_open_branch_result cache.
176
416
        # See create_branch for rationale.
177
417
        self._next_open_branch_result = None
178
 
        return BzrDir.break_lock(self)
 
418
        return _mod_bzrdir.BzrDir.break_lock(self)
179
419
 
180
420
    def _vfs_cloning_metadir(self, require_stacking=False):
181
421
        self._ensure_real()
212
452
        if len(branch_info) != 2:
213
453
            raise errors.UnexpectedSmartServerResponse(response)
214
454
        branch_ref, branch_name = branch_info
215
 
        format = bzrdir.network_format_registry.get(control_name)
 
455
        format = controldir.network_format_registry.get(control_name)
216
456
        if repo_name:
217
 
            format.repository_format = repository.network_format_registry.get(
 
457
            format.repository_format = _mod_repository.network_format_registry.get(
218
458
                repo_name)
219
459
        if branch_ref == 'ref':
220
460
            # XXX: we need possible_transports here to avoid reopening the
221
461
            # connection to the referenced location
222
 
            ref_bzrdir = BzrDir.open(branch_name)
 
462
            ref_bzrdir = _mod_bzrdir.BzrDir.open(branch_name)
223
463
            branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
224
464
            format.set_branch_format(branch_format)
225
465
        elif branch_ref == 'branch':
244
484
        self._ensure_real()
245
485
        self._real_bzrdir.destroy_repository()
246
486
 
247
 
    def create_branch(self, name=None):
 
487
    def create_branch(self, name=None, repository=None):
248
488
        # as per meta1 formats - just delegate to the format object which may
249
489
        # be parameterised.
250
490
        real_branch = self._format.get_branch_format().initialize(self,
251
 
            name=name)
 
491
            name=name, repository=repository)
252
492
        if not isinstance(real_branch, RemoteBranch):
253
 
            result = RemoteBranch(self, self.find_repository(), real_branch,
254
 
                                  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)
255
498
        else:
256
499
            result = real_branch
257
500
        # BzrDir.clone_on_transport() uses the result of create_branch but does
269
512
        self._real_bzrdir.destroy_branch(name=name)
270
513
        self._next_open_branch_result = None
271
514
 
272
 
    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):
273
517
        raise errors.NotLocalUrl(self.transport.base)
274
518
 
275
 
    def find_branch_format(self):
 
519
    def find_branch_format(self, name=None):
276
520
        """Find the branch 'format' for this bzrdir.
277
521
 
278
522
        This might be a synthetic object for e.g. RemoteBranch and SVN.
279
523
        """
280
 
        b = self.open_branch()
 
524
        b = self.open_branch(name=name)
281
525
        return b._format
282
526
 
283
 
    def get_branch_reference(self):
 
527
    def get_branch_reference(self, name=None):
284
528
        """See BzrDir.get_branch_reference()."""
 
529
        if name is not None:
 
530
            # XXX JRV20100304: Support opening colocated branches
 
531
            raise errors.NoColocatedBranchSupport(self)
285
532
        response = self._get_branch_reference()
286
533
        if response[0] == 'ref':
287
534
            return response[1]
318
565
            raise errors.UnexpectedSmartServerResponse(response)
319
566
        return response
320
567
 
321
 
    def _get_tree_branch(self):
 
568
    def _get_tree_branch(self, name=None):
322
569
        """See BzrDir._get_tree_branch()."""
323
 
        return None, self.open_branch()
 
570
        return None, self.open_branch(name=name)
324
571
 
325
572
    def open_branch(self, name=None, unsupported=False,
326
573
                    ignore_fallbacks=False):
441
688
        """Upgrading of remote bzrdirs is not supported yet."""
442
689
        return False
443
690
 
444
 
    def needs_format_conversion(self, format=None):
 
691
    def needs_format_conversion(self, format):
445
692
        """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
693
        return False
450
694
 
451
695
    def clone(self, url, revision_id=None, force_new_repo=False,
458
702
        return RemoteBzrDirConfig(self)
459
703
 
460
704
 
461
 
class RemoteRepositoryFormat(repository.RepositoryFormat):
 
705
class RemoteRepositoryFormat(vf_repository.VersionedFileRepositoryFormat):
462
706
    """Format for repositories accessed over a _SmartClient.
463
707
 
464
708
    Instances of this repository are represented by RemoteRepository
479
723
    """
480
724
 
481
725
    _matchingbzrdir = RemoteBzrDirFormat()
 
726
    supports_full_versioned_files = True
 
727
    supports_leaving_lock = True
482
728
 
483
729
    def __init__(self):
484
 
        repository.RepositoryFormat.__init__(self)
 
730
        _mod_repository.RepositoryFormat.__init__(self)
485
731
        self._custom_format = None
486
732
        self._network_name = None
487
733
        self._creating_bzrdir = None
 
734
        self._revision_graph_can_have_wrong_parents = None
488
735
        self._supports_chks = None
489
736
        self._supports_external_lookups = None
490
737
        self._supports_tree_reference = None
 
738
        self._supports_funky_characters = None
491
739
        self._rich_root_data = None
492
740
 
493
741
    def __repr__(self):
522
770
        return self._supports_external_lookups
523
771
 
524
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
525
781
    def supports_tree_reference(self):
526
782
        if self._supports_tree_reference is None:
527
783
            self._ensure_real()
529
785
                self._custom_format.supports_tree_reference
530
786
        return self._supports_tree_reference
531
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
 
532
796
    def _vfs_initialize(self, a_bzrdir, shared):
533
797
        """Helper for common code in initialize."""
534
798
        if self._custom_format:
569
833
            network_name = self._network_name
570
834
        else:
571
835
            # Select the current bzrlib default and ask for that.
572
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
836
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
573
837
            reference_format = reference_bzrdir_format.repository_format
574
838
            network_name = reference_format.network_name()
575
839
        # 2) try direct creation via RPC
601
865
 
602
866
    def _ensure_real(self):
603
867
        if self._custom_format is None:
604
 
            self._custom_format = repository.network_format_registry.get(
 
868
            self._custom_format = _mod_repository.network_format_registry.get(
605
869
                self._network_name)
606
870
 
607
871
    @property
644
908
 
645
909
 
646
910
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
647
 
    bzrdir.ControlComponent):
 
911
    controldir.ControlComponent):
648
912
    """Repository accessed over rpc.
649
913
 
650
914
    For the moment most operations are performed using local transport-backed
703
967
        # transport, but I'm not sure it's worth making this method
704
968
        # optional -- mbp 2010-04-21
705
969
        return self.bzrdir.get_repository_transport(None)
706
 
        
 
970
 
707
971
    def __str__(self):
708
972
        return "%s(%s)" % (self.__class__.__name__, self.base)
709
973
 
817
1081
    def find_text_key_references(self):
818
1082
        """Find the text key references within the repository.
819
1083
 
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
1084
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
824
1085
            to whether they were referred to by the inventory of the
825
1086
            revision_id that they contain. The inventory texts from all present
843
1104
        """Private method for using with old (< 1.2) servers to fallback."""
844
1105
        if revision_id is None:
845
1106
            revision_id = ''
846
 
        elif revision.is_null(revision_id):
 
1107
        elif _mod_revision.is_null(revision_id):
847
1108
            return {}
848
1109
 
849
1110
        path = self.bzrdir._path_for_remote_call(self._client)
873
1134
        return RemoteStreamSource(self, to_format)
874
1135
 
875
1136
    @needs_read_lock
 
1137
    def get_file_graph(self):
 
1138
        return graph.Graph(self.texts)
 
1139
 
 
1140
    @needs_read_lock
876
1141
    def has_revision(self, revision_id):
877
1142
        """True if this repository has a copy of the revision."""
878
1143
        # Copy of bzrlib.repository.Repository.has_revision
895
1160
    def _has_same_fallbacks(self, other_repo):
896
1161
        """Returns true if the repositories have the same fallbacks."""
897
1162
        # XXX: copied from Repository; it should be unified into a base class
898
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
 
1163
        # <https://bugs.launchpad.net/bzr/+bug/401622>
899
1164
        my_fb = self._fallback_repositories
900
1165
        other_fb = other_repo._fallback_repositories
901
1166
        if len(my_fb) != len(other_fb):
930
1195
        """See Repository.gather_stats()."""
931
1196
        path = self.bzrdir._path_for_remote_call(self._client)
932
1197
        # revid can be None to indicate no revisions, not just NULL_REVISION
933
 
        if revid is None or revision.is_null(revid):
 
1198
        if revid is None or _mod_revision.is_null(revid):
934
1199
            fmt_revid = ''
935
1200
        else:
936
1201
            fmt_revid = revid
997
1262
        pass
998
1263
 
999
1264
    def lock_read(self):
 
1265
        """Lock the repository for read operations.
 
1266
 
 
1267
        :return: A bzrlib.lock.LogicalLockResult.
 
1268
        """
1000
1269
        # wrong eventually - want a local lock cache context
1001
1270
        if not self._lock_mode:
1002
1271
            self._note_lock('r')
1009
1278
                repo.lock_read()
1010
1279
        else:
1011
1280
            self._lock_count += 1
 
1281
        return lock.LogicalLockResult(self.unlock)
1012
1282
 
1013
1283
    def _remote_lock_write(self, token):
1014
1284
        path = self.bzrdir._path_for_remote_call(self._client)
1054
1324
            raise errors.ReadOnlyError(self)
1055
1325
        else:
1056
1326
            self._lock_count += 1
1057
 
        return self._lock_token or None
 
1327
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
1058
1328
 
1059
1329
    def leave_lock_in_place(self):
1060
1330
        if not self._lock_token:
1214
1484
 
1215
1485
    def get_commit_builder(self, branch, parents, config, timestamp=None,
1216
1486
                           timezone=None, committer=None, revprops=None,
1217
 
                           revision_id=None):
 
1487
                           revision_id=None, lossy=False):
1218
1488
        # FIXME: It ought to be possible to call this without immediately
1219
1489
        # triggering _ensure_real.  For now it's the easiest thing to do.
1220
1490
        self._ensure_real()
1221
1491
        real_repo = self._real_repository
1222
1492
        builder = real_repo.get_commit_builder(branch, parents,
1223
1493
                config, timestamp=timestamp, timezone=timezone,
1224
 
                committer=committer, revprops=revprops, revision_id=revision_id)
 
1494
                committer=committer, revprops=revprops,
 
1495
                revision_id=revision_id, lossy=lossy)
1225
1496
        return builder
1226
1497
 
1227
1498
    def add_fallback_repository(self, repository):
1306
1577
        return self._real_repository.make_working_trees()
1307
1578
 
1308
1579
    def refresh_data(self):
1309
 
        """Re-read any data needed to to synchronise with disk.
 
1580
        """Re-read any data needed to synchronise with disk.
1310
1581
 
1311
1582
        This method is intended to be called after another repository instance
1312
1583
        (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.
 
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.
1315
1589
        """
1316
 
        if self.is_in_write_group():
1317
 
            raise errors.InternalBzrError(
1318
 
                "May not refresh_data while in a write group.")
1319
1590
        if self._real_repository is not None:
1320
1591
            self._real_repository.refresh_data()
1321
1592
 
1333
1604
        return result
1334
1605
 
1335
1606
    @needs_read_lock
1336
 
    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,
 
1610
            limit=None):
1337
1611
        """Return the revision ids that other has that this does not.
1338
1612
 
1339
1613
        These are returned in topological order.
1340
1614
 
1341
1615
        revision_id: only return revision ids included by revision_id.
1342
1616
        """
1343
 
        return repository.InterRepository.get(
1344
 
            other, self).search_missing_revision_ids(revision_id, find_ghosts)
 
1617
        if symbol_versioning.deprecated_passed(revision_id):
 
1618
            symbol_versioning.warn(
 
1619
                'search_missing_revision_ids(revision_id=...) was '
 
1620
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
 
1621
                DeprecationWarning, stacklevel=2)
 
1622
            if revision_ids is not None:
 
1623
                raise AssertionError(
 
1624
                    'revision_ids is mutually exclusive with revision_id')
 
1625
            if revision_id is not None:
 
1626
                revision_ids = [revision_id]
 
1627
        inter_repo = _mod_repository.InterRepository.get(other, self)
 
1628
        return inter_repo.search_missing_revision_ids(
 
1629
            find_ghosts=find_ghosts, revision_ids=revision_ids,
 
1630
            if_present_ids=if_present_ids, limit=limit)
1345
1631
 
1346
 
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
 
1632
    def fetch(self, source, revision_id=None, find_ghosts=False,
1347
1633
            fetch_spec=None):
1348
1634
        # No base implementation to use as RemoteRepository is not a subclass
1349
1635
        # of Repository; so this is a copy of Repository.fetch().
1360
1646
            # check that last_revision is in 'from' and then return a
1361
1647
            # no-operation.
1362
1648
            if (revision_id is not None and
1363
 
                not revision.is_null(revision_id)):
 
1649
                not _mod_revision.is_null(revision_id)):
1364
1650
                self.get_revision(revision_id)
1365
1651
            return 0, []
1366
1652
        # if there is no specific appropriate InterRepository, this will get
1367
1653
        # the InterRepository base class, which raises an
1368
1654
        # IncompatibleRepositories when asked to fetch.
1369
 
        inter = repository.InterRepository.get(source, self)
1370
 
        return inter.fetch(revision_id=revision_id, pb=pb,
 
1655
        inter = _mod_repository.InterRepository.get(source, self)
 
1656
        return inter.fetch(revision_id=revision_id,
1371
1657
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1372
1658
 
1373
1659
    def create_bundle(self, target, base, fileobj, format=None):
1597
1883
            tmpdir = osutils.mkdtemp()
1598
1884
            try:
1599
1885
                _extract_tar(tar, tmpdir)
1600
 
                tmp_bzrdir = BzrDir.open(tmpdir)
 
1886
                tmp_bzrdir = _mod_bzrdir.BzrDir.open(tmpdir)
1601
1887
                tmp_repo = tmp_bzrdir.open_repository()
1602
1888
                tmp_repo.copy_content_into(destination, revision_id)
1603
1889
            finally:
1688
1974
    def supports_rich_root(self):
1689
1975
        return self._format.rich_root_data
1690
1976
 
 
1977
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
1691
1978
    def iter_reverse_revision_history(self, revision_id):
1692
1979
        self._ensure_real()
1693
1980
        return self._real_repository.iter_reverse_revision_history(revision_id)
1714
2001
        return self._real_repository.item_keys_introduced_by(revision_ids,
1715
2002
            _files_pb=_files_pb)
1716
2003
 
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
2004
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
1723
2005
        self._ensure_real()
1724
2006
        return self._real_repository._find_inconsistent_revision_parents(
1732
2014
        providers = [self._unstacked_provider]
1733
2015
        if other is not None:
1734
2016
            providers.insert(0, other)
1735
 
        providers.extend(r._make_parents_provider() for r in
1736
 
                         self._fallback_repositories)
1737
 
        return graph.StackedParentsProvider(providers)
 
2017
        return graph.StackedParentsProvider(_LazyListJoin(
 
2018
            providers, self._fallback_repositories))
1738
2019
 
1739
2020
    def _serialise_search_recipe(self, recipe):
1740
2021
        """Serialise a graph search recipe.
1748
2029
        return '\n'.join((start_keys, stop_keys, count))
1749
2030
 
1750
2031
    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)]
 
2032
        parts = search_result.get_network_struct()
1757
2033
        return '\n'.join(parts)
1758
2034
 
1759
2035
    def autopack(self):
1769
2045
            raise errors.UnexpectedSmartServerResponse(response)
1770
2046
 
1771
2047
 
1772
 
class RemoteStreamSink(repository.StreamSink):
 
2048
class RemoteStreamSink(vf_repository.StreamSink):
1773
2049
 
1774
2050
    def _insert_real(self, stream, src_format, resume_tokens):
1775
2051
        self.target_repo._ensure_real()
1876
2152
        self._last_substream and self._last_stream so that the stream can be
1877
2153
        resumed by _resume_stream_with_vfs.
1878
2154
        """
1879
 
                    
 
2155
 
1880
2156
        stream_iter = iter(stream)
1881
2157
        for substream_kind, substream in stream_iter:
1882
2158
            if substream_kind == 'inventory-deltas':
1885
2161
                return
1886
2162
            else:
1887
2163
                yield substream_kind, substream
1888
 
            
1889
 
 
1890
 
class RemoteStreamSource(repository.StreamSource):
 
2164
 
 
2165
 
 
2166
class RemoteStreamSource(vf_repository.StreamSource):
1891
2167
    """Stream data from a remote server."""
1892
2168
 
1893
2169
    def get_stream(self, search):
1953
2229
        candidate_verbs = [
1954
2230
            ('Repository.get_stream_1.19', (1, 19)),
1955
2231
            ('Repository.get_stream', (1, 13))]
 
2232
 
1956
2233
        found_verb = False
1957
2234
        for verb, version in candidate_verbs:
1958
2235
            if medium._is_remote_before(version):
1962
2239
                    verb, args, search_bytes)
1963
2240
            except errors.UnknownSmartMethod:
1964
2241
                medium._remember_remote_is_before(version)
 
2242
            except errors.UnknownErrorFromSmartServer, e:
 
2243
                if isinstance(search, graph.EverythingResult):
 
2244
                    error_verb = e.error_from_smart_server.error_verb
 
2245
                    if error_verb == 'BadSearch':
 
2246
                        # Pre-2.4 servers don't support this sort of search.
 
2247
                        # XXX: perhaps falling back to VFS on BadSearch is a
 
2248
                        # good idea in general?  It might provide a little bit
 
2249
                        # of protection against client-side bugs.
 
2250
                        medium._remember_remote_is_before((2, 4))
 
2251
                        break
 
2252
                raise
1965
2253
            else:
1966
2254
                response_tuple, response_handler = response
1967
2255
                found_verb = True
1971
2259
        if response_tuple[0] != 'ok':
1972
2260
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1973
2261
        byte_stream = response_handler.read_streamed_body()
1974
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
 
2262
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
 
2263
            self._record_counter)
1975
2264
        if src_format.network_name() != repo._format.network_name():
1976
2265
            raise AssertionError(
1977
2266
                "Mismatched RemoteRepository and stream src %r, %r" % (
2081
2370
                                  name=name)
2082
2371
        return result
2083
2372
 
2084
 
    def initialize(self, a_bzrdir, name=None):
 
2373
    def initialize(self, a_bzrdir, name=None, repository=None):
2085
2374
        # 1) get the network name to use.
2086
2375
        if self._custom_format:
2087
2376
            network_name = self._custom_format.network_name()
2088
2377
        else:
2089
2378
            # Select the current bzrlib default and ask for that.
2090
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
2379
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
2091
2380
            reference_format = reference_bzrdir_format.get_branch_format()
2092
2381
            self._custom_format = reference_format
2093
2382
            network_name = reference_format.network_name()
2115
2404
        # Turn the response into a RemoteRepository object.
2116
2405
        format = RemoteBranchFormat(network_name=response[1])
2117
2406
        repo_format = response_tuple_to_repo_format(response[3:])
2118
 
        if response[2] == '':
2119
 
            repo_bzrdir = a_bzrdir
 
2407
        repo_path = response[2]
 
2408
        if repository is not None:
 
2409
            remote_repo_url = urlutils.join(a_bzrdir.user_url, repo_path)
 
2410
            url_diff = urlutils.relative_url(repository.user_url,
 
2411
                    remote_repo_url)
 
2412
            if url_diff != '.':
 
2413
                raise AssertionError(
 
2414
                    'repository.user_url %r does not match URL from server '
 
2415
                    'response (%r + %r)'
 
2416
                    % (repository.user_url, a_bzrdir.user_url, repo_path))
 
2417
            remote_repo = repository
2120
2418
        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)
 
2419
            if repo_path == '':
 
2420
                repo_bzrdir = a_bzrdir
 
2421
            else:
 
2422
                repo_bzrdir = RemoteBzrDir(
 
2423
                    a_bzrdir.root_transport.clone(repo_path), a_bzrdir._format,
 
2424
                    a_bzrdir._client)
 
2425
            remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2125
2426
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2126
2427
            format=format, setup_stacking=False, name=name)
2127
2428
        # XXX: We know this is a new branch, so it must have revno 0, revid
2148
2449
        self._ensure_real()
2149
2450
        return self._custom_format.supports_set_append_revisions_only()
2150
2451
 
 
2452
    def _use_default_local_heads_to_fetch(self):
 
2453
        # If the branch format is a metadir format *and* its heads_to_fetch
 
2454
        # implementation is not overridden vs the base class, we can use the
 
2455
        # base class logic rather than use the heads_to_fetch RPC.  This is
 
2456
        # usually cheaper in terms of net round trips, as the last-revision and
 
2457
        # tags info fetched is cached and would be fetched anyway.
 
2458
        self._ensure_real()
 
2459
        if isinstance(self._custom_format, branch.BranchFormatMetadir):
 
2460
            branch_class = self._custom_format._branch_class()
 
2461
            heads_to_fetch_impl = branch_class.heads_to_fetch.im_func
 
2462
            if heads_to_fetch_impl is branch.Branch.heads_to_fetch.im_func:
 
2463
                return True
 
2464
        return False
2151
2465
 
2152
2466
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
2153
2467
    """Branch stored on a server accessed by HPSS RPC.
2352
2666
            self._is_stacked = False
2353
2667
        else:
2354
2668
            self._is_stacked = True
2355
 
        
 
2669
 
2356
2670
    def _vfs_get_tags_bytes(self):
2357
2671
        self._ensure_real()
2358
2672
        return self._real_branch._get_tags_bytes()
2359
2673
 
 
2674
    @needs_read_lock
2360
2675
    def _get_tags_bytes(self):
 
2676
        if self._tags_bytes is None:
 
2677
            self._tags_bytes = self._get_tags_bytes_via_hpss()
 
2678
        return self._tags_bytes
 
2679
 
 
2680
    def _get_tags_bytes_via_hpss(self):
2361
2681
        medium = self._client._medium
2362
2682
        if medium._is_remote_before((1, 13)):
2363
2683
            return self._vfs_get_tags_bytes()
2373
2693
        return self._real_branch._set_tags_bytes(bytes)
2374
2694
 
2375
2695
    def _set_tags_bytes(self, bytes):
 
2696
        if self.is_locked():
 
2697
            self._tags_bytes = bytes
2376
2698
        medium = self._client._medium
2377
2699
        if medium._is_remote_before((1, 18)):
2378
2700
            self._vfs_set_tags_bytes(bytes)
2387
2709
            self._vfs_set_tags_bytes(bytes)
2388
2710
 
2389
2711
    def lock_read(self):
 
2712
        """Lock the branch for read operations.
 
2713
 
 
2714
        :return: A bzrlib.lock.LogicalLockResult.
 
2715
        """
2390
2716
        self.repository.lock_read()
2391
2717
        if not self._lock_mode:
2392
2718
            self._note_lock('r')
2396
2722
                self._real_branch.lock_read()
2397
2723
        else:
2398
2724
            self._lock_count += 1
 
2725
        return lock.LogicalLockResult(self.unlock)
2399
2726
 
2400
2727
    def _remote_lock_write(self, token):
2401
2728
        if token is None:
2402
2729
            branch_token = repo_token = ''
2403
2730
        else:
2404
2731
            branch_token = token
2405
 
            repo_token = self.repository.lock_write()
 
2732
            repo_token = self.repository.lock_write().repository_token
2406
2733
            self.repository.unlock()
2407
2734
        err_context = {'token': token}
2408
 
        response = self._call(
2409
 
            'Branch.lock_write', self._remote_path(), branch_token,
2410
 
            repo_token or '', **err_context)
 
2735
        try:
 
2736
            response = self._call(
 
2737
                'Branch.lock_write', self._remote_path(), branch_token,
 
2738
                repo_token or '', **err_context)
 
2739
        except errors.LockContention, e:
 
2740
            # The LockContention from the server doesn't have any
 
2741
            # information about the lock_url. We re-raise LockContention
 
2742
            # with valid lock_url.
 
2743
            raise errors.LockContention('(remote lock)',
 
2744
                self.repository.base.split('.bzr/')[0])
2411
2745
        if response[0] != 'ok':
2412
2746
            raise errors.UnexpectedSmartServerResponse(response)
2413
2747
        ok, branch_token, repo_token = response
2434
2768
            self._lock_mode = 'w'
2435
2769
            self._lock_count = 1
2436
2770
        elif self._lock_mode == 'r':
2437
 
            raise errors.ReadOnlyTransaction
 
2771
            raise errors.ReadOnlyError(self)
2438
2772
        else:
2439
2773
            if token is not None:
2440
2774
                # A token was given to lock_write, and we're relocking, so
2445
2779
            self._lock_count += 1
2446
2780
            # Re-lock the repository too.
2447
2781
            self.repository.lock_write(self._repo_lock_token)
2448
 
        return self._lock_token or None
 
2782
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
2449
2783
 
2450
2784
    def _unlock(self, branch_token, repo_token):
2451
2785
        err_context = {'token': str((branch_token, repo_token))}
2520
2854
            missing_parent = parent_map[missing_parent]
2521
2855
        raise errors.RevisionNotPresent(missing_parent, self.repository)
2522
2856
 
2523
 
    def _last_revision_info(self):
 
2857
    def _read_last_revision_info(self):
2524
2858
        response = self._call('Branch.last_revision_info', self._remote_path())
2525
2859
        if response[0] != 'ok':
2526
2860
            raise SmartProtocolError('unexpected response code %s' % (response,))
2589
2923
            raise errors.UnexpectedSmartServerResponse(response)
2590
2924
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2591
2925
 
 
2926
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2592
2927
    @needs_write_lock
2593
2928
    def set_revision_history(self, rev_history):
 
2929
        """See Branch.set_revision_history."""
 
2930
        self._set_revision_history(rev_history)
 
2931
 
 
2932
    @needs_write_lock
 
2933
    def _set_revision_history(self, rev_history):
2594
2934
        # Send just the tip revision of the history; the server will generate
2595
2935
        # the full history from that.  If the revision doesn't exist in this
2596
2936
        # branch, NoSuchRevision will be raised.
2654
2994
            _override_hook_target=self, **kwargs)
2655
2995
 
2656
2996
    @needs_read_lock
2657
 
    def push(self, target, overwrite=False, stop_revision=None):
 
2997
    def push(self, target, overwrite=False, stop_revision=None, lossy=False):
2658
2998
        self._ensure_real()
2659
2999
        return self._real_branch.push(
2660
 
            target, overwrite=overwrite, stop_revision=stop_revision,
 
3000
            target, overwrite=overwrite, stop_revision=stop_revision, lossy=lossy,
2661
3001
            _override_hook_source_branch=self)
2662
3002
 
2663
3003
    def is_locked(self):
2673
3013
        # XXX: These should be returned by the set_last_revision_info verb
2674
3014
        old_revno, old_revid = self.last_revision_info()
2675
3015
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
2676
 
        revision_id = ensure_null(revision_id)
 
3016
        if not revision_id or not isinstance(revision_id, basestring):
 
3017
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2677
3018
        try:
2678
3019
            response = self._call('Branch.set_last_revision_info',
2679
3020
                self._remote_path(), self._lock_token, self._repo_lock_token,
2708
3049
            except errors.UnknownSmartMethod:
2709
3050
                medium._remember_remote_is_before((1, 6))
2710
3051
        self._clear_cached_state_of_remote_branch_only()
2711
 
        self.set_revision_history(self._lefthand_history(revision_id,
 
3052
        self._set_revision_history(self._lefthand_history(revision_id,
2712
3053
            last_rev=last_rev,other_branch=other_branch))
2713
3054
 
2714
3055
    def set_push_location(self, location):
2715
3056
        self._ensure_real()
2716
3057
        return self._real_branch.set_push_location(location)
2717
3058
 
 
3059
    def heads_to_fetch(self):
 
3060
        if self._format._use_default_local_heads_to_fetch():
 
3061
            # We recognise this format, and its heads-to-fetch implementation
 
3062
            # is the default one (tip + tags).  In this case it's cheaper to
 
3063
            # just use the default implementation rather than a special RPC as
 
3064
            # the tip and tags data is cached.
 
3065
            return branch.Branch.heads_to_fetch(self)
 
3066
        medium = self._client._medium
 
3067
        if medium._is_remote_before((2, 4)):
 
3068
            return self._vfs_heads_to_fetch()
 
3069
        try:
 
3070
            return self._rpc_heads_to_fetch()
 
3071
        except errors.UnknownSmartMethod:
 
3072
            medium._remember_remote_is_before((2, 4))
 
3073
            return self._vfs_heads_to_fetch()
 
3074
 
 
3075
    def _rpc_heads_to_fetch(self):
 
3076
        response = self._call('Branch.heads_to_fetch', self._remote_path())
 
3077
        if len(response) != 2:
 
3078
            raise errors.UnexpectedSmartServerResponse(response)
 
3079
        must_fetch, if_present_fetch = response
 
3080
        return set(must_fetch), set(if_present_fetch)
 
3081
 
 
3082
    def _vfs_heads_to_fetch(self):
 
3083
        self._ensure_real()
 
3084
        return self._real_branch.heads_to_fetch()
 
3085
 
2718
3086
 
2719
3087
class RemoteConfig(object):
2720
3088
    """A Config that reads and writes from smart verbs.
2774
3142
        medium = self._branch._client._medium
2775
3143
        if medium._is_remote_before((1, 14)):
2776
3144
            return self._vfs_set_option(value, name, section)
 
3145
        if isinstance(value, dict):
 
3146
            if medium._is_remote_before((2, 2)):
 
3147
                return self._vfs_set_option(value, name, section)
 
3148
            return self._set_config_option_dict(value, name, section)
 
3149
        else:
 
3150
            return self._set_config_option(value, name, section)
 
3151
 
 
3152
    def _set_config_option(self, value, name, section):
2777
3153
        try:
2778
3154
            path = self._branch._remote_path()
2779
3155
            response = self._branch._client.call('Branch.set_config_option',
2780
3156
                path, self._branch._lock_token, self._branch._repo_lock_token,
2781
3157
                value.encode('utf8'), name, section or '')
2782
3158
        except errors.UnknownSmartMethod:
 
3159
            medium = self._branch._client._medium
2783
3160
            medium._remember_remote_is_before((1, 14))
2784
3161
            return self._vfs_set_option(value, name, section)
2785
3162
        if response != ():
2786
3163
            raise errors.UnexpectedSmartServerResponse(response)
2787
3164
 
 
3165
    def _serialize_option_dict(self, option_dict):
 
3166
        utf8_dict = {}
 
3167
        for key, value in option_dict.items():
 
3168
            if isinstance(key, unicode):
 
3169
                key = key.encode('utf8')
 
3170
            if isinstance(value, unicode):
 
3171
                value = value.encode('utf8')
 
3172
            utf8_dict[key] = value
 
3173
        return bencode.bencode(utf8_dict)
 
3174
 
 
3175
    def _set_config_option_dict(self, value, name, section):
 
3176
        try:
 
3177
            path = self._branch._remote_path()
 
3178
            serialised_dict = self._serialize_option_dict(value)
 
3179
            response = self._branch._client.call(
 
3180
                'Branch.set_config_option_dict',
 
3181
                path, self._branch._lock_token, self._branch._repo_lock_token,
 
3182
                serialised_dict, name, section or '')
 
3183
        except errors.UnknownSmartMethod:
 
3184
            medium = self._branch._client._medium
 
3185
            medium._remember_remote_is_before((2, 2))
 
3186
            return self._vfs_set_option(value, name, section)
 
3187
        if response != ():
 
3188
            raise errors.UnexpectedSmartServerResponse(response)
 
3189
 
2788
3190
    def _real_object(self):
2789
3191
        self._branch._ensure_real()
2790
3192
        return self._branch._real_branch
2873
3275
                    'Missing key %r in context %r', key_err.args[0], context)
2874
3276
                raise err
2875
3277
 
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':
 
3278
    if err.error_verb == 'NoSuchRevision':
2880
3279
        raise NoSuchRevision(find('branch'), err.error_args[0])
2881
3280
    elif err.error_verb == 'nosuchrevision':
2882
3281
        raise NoSuchRevision(find('repository'), err.error_args[0])
2889
3288
            detail=extra)
2890
3289
    elif err.error_verb == 'norepository':
2891
3290
        raise errors.NoRepositoryPresent(find('bzrdir'))
2892
 
    elif err.error_verb == 'LockContention':
2893
 
        raise errors.LockContention('(remote lock)')
2894
3291
    elif err.error_verb == 'UnlockableTransport':
2895
3292
        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
3293
    elif err.error_verb == 'TokenMismatch':
2899
3294
        raise errors.TokenMismatch(find('token'), '(remote token)')
2900
3295
    elif err.error_verb == 'Diverged':
2901
3296
        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
3297
    elif err.error_verb == 'NotStacked':
2909
3298
        raise errors.NotStacked(branch=find('branch'))
2910
3299
    elif err.error_verb == 'PermissionDenied':
2920
3309
    elif err.error_verb == 'NoSuchFile':
2921
3310
        path = get_path()
2922
3311
        raise errors.NoSuchFile(path)
 
3312
    _translate_error_without_context(err)
 
3313
 
 
3314
 
 
3315
def _translate_error_without_context(err):
 
3316
    """Translate any ErrorFromSmartServer values that don't require context"""
 
3317
    if err.error_verb == 'IncompatibleRepositories':
 
3318
        raise errors.IncompatibleRepositories(err.error_args[0],
 
3319
            err.error_args[1], err.error_args[2])
 
3320
    elif err.error_verb == 'LockContention':
 
3321
        raise errors.LockContention('(remote lock)')
 
3322
    elif err.error_verb == 'LockFailed':
 
3323
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
 
3324
    elif err.error_verb == 'TipChangeRejected':
 
3325
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
 
3326
    elif err.error_verb == 'UnstackableBranchFormat':
 
3327
        raise errors.UnstackableBranchFormat(*err.error_args)
 
3328
    elif err.error_verb == 'UnstackableRepositoryFormat':
 
3329
        raise errors.UnstackableRepositoryFormat(*err.error_args)
2923
3330
    elif err.error_verb == 'FileExists':
2924
3331
        raise errors.FileExists(err.error_args[0])
2925
3332
    elif err.error_verb == 'DirectoryNotEmpty':
2944
3351
            raise UnicodeEncodeError(encoding, val, start, end, reason)
2945
3352
    elif err.error_verb == 'ReadOnlyError':
2946
3353
        raise errors.TransportNotPossible('readonly transport')
 
3354
    elif err.error_verb == 'MemoryError':
 
3355
        raise errors.BzrError("remote server out of memory\n"
 
3356
            "Retry non-remotely, or contact the server admin for details.")
2947
3357
    raise errors.UnknownErrorFromSmartServer(err)