← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: Robert Collins
  • Date: 2010-05-11 08:36:16 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100511083616-b8fjb19zomwupid0
Make all lock methods return Result objects, rather than lock_read returning self, as per John's review.

Show diffs side-by-side

added added

removed removed

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