← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: Vincent Ladeuil
  • Date: 2011-06-27 15:42:09 UTC
  • mfrom: (5993 +trunk)
  • mto: (5993.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 5994.
  • Revision ID: v.ladeuil+lp@free.fr-20110627154209-azubuhbuxsz109hq
Merge trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
19
19
from bzrlib import (
20
20
    bencode,
21
21
    branch,
22
 
    bzrdir,
 
22
    bzrdir as _mod_bzrdir,
23
23
    config,
 
24
    controldir,
24
25
    debug,
25
26
    errors,
26
27
    graph,
27
28
    lock,
28
29
    lockdir,
29
 
    repository,
30
30
    repository as _mod_repository,
31
 
    revision,
32
31
    revision as _mod_revision,
33
32
    static_tuple,
34
33
    symbol_versioning,
35
 
)
 
34
    urlutils,
 
35
    vf_repository,
 
36
    )
36
37
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.revision import ensure_null, NULL_REVISION
46
 
from bzrlib.repository import RepositoryWriteLockResult
 
45
from bzrlib.smart.client import _SmartClient
 
46
from bzrlib.revision import NULL_REVISION
 
47
from bzrlib.repository import RepositoryWriteLockResult, _LazyListJoin
47
48
from bzrlib.trace import mutter, note, warning
48
49
 
49
50
 
87
88
    return format
88
89
 
89
90
 
90
 
# Note: RemoteBzrDirFormat is in bzrdir.py
91
 
 
92
 
class RemoteBzrDir(BzrDir, _RpcHelper):
 
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):
93
331
    """Control directory on a remote server, accessed via bzr:// or similar."""
94
332
 
95
333
    def __init__(self, transport, format, _client=None, _force_probe=False):
98
336
        :param _client: Private parameter for testing. Disables probing and the
99
337
            use of a real bzrdir.
100
338
        """
101
 
        BzrDir.__init__(self, transport, format)
 
339
        _mod_bzrdir.BzrDir.__init__(self, transport, format)
102
340
        # this object holds a delegated bzrdir that uses file-level operations
103
341
        # to talk to the other side
104
342
        self._real_bzrdir = None
164
402
                import traceback
165
403
                warning('VFS BzrDir access triggered\n%s',
166
404
                    ''.join(traceback.format_stack()))
167
 
            self._real_bzrdir = BzrDir.open_from_transport(
 
405
            self._real_bzrdir = _mod_bzrdir.BzrDir.open_from_transport(
168
406
                self.root_transport, _server_formats=False)
169
407
            self._format._network_name = \
170
408
                self._real_bzrdir._format.network_name()
176
414
        # Prevent aliasing problems in the next_open_branch_result cache.
177
415
        # See create_branch for rationale.
178
416
        self._next_open_branch_result = None
179
 
        return BzrDir.break_lock(self)
 
417
        return _mod_bzrdir.BzrDir.break_lock(self)
180
418
 
181
419
    def _vfs_cloning_metadir(self, require_stacking=False):
182
420
        self._ensure_real()
213
451
        if len(branch_info) != 2:
214
452
            raise errors.UnexpectedSmartServerResponse(response)
215
453
        branch_ref, branch_name = branch_info
216
 
        format = bzrdir.network_format_registry.get(control_name)
 
454
        format = controldir.network_format_registry.get(control_name)
217
455
        if repo_name:
218
 
            format.repository_format = repository.network_format_registry.get(
 
456
            format.repository_format = _mod_repository.network_format_registry.get(
219
457
                repo_name)
220
458
        if branch_ref == 'ref':
221
459
            # XXX: we need possible_transports here to avoid reopening the
222
460
            # connection to the referenced location
223
 
            ref_bzrdir = BzrDir.open(branch_name)
 
461
            ref_bzrdir = _mod_bzrdir.BzrDir.open(branch_name)
224
462
            branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
225
463
            format.set_branch_format(branch_format)
226
464
        elif branch_ref == 'branch':
245
483
        self._ensure_real()
246
484
        self._real_bzrdir.destroy_repository()
247
485
 
248
 
    def create_branch(self, name=None):
 
486
    def create_branch(self, name=None, repository=None):
249
487
        # as per meta1 formats - just delegate to the format object which may
250
488
        # be parameterised.
251
489
        real_branch = self._format.get_branch_format().initialize(self,
252
 
            name=name)
 
490
            name=name, repository=repository)
253
491
        if not isinstance(real_branch, RemoteBranch):
254
 
            result = RemoteBranch(self, self.find_repository(), real_branch,
255
 
                                  name=name)
 
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)
256
497
        else:
257
498
            result = real_branch
258
499
        # BzrDir.clone_on_transport() uses the result of create_branch but does
270
511
        self._real_bzrdir.destroy_branch(name=name)
271
512
        self._next_open_branch_result = None
272
513
 
273
 
    def create_workingtree(self, revision_id=None, from_branch=None):
 
514
    def create_workingtree(self, revision_id=None, from_branch=None,
 
515
        accelerator_tree=None, hardlink=False):
274
516
        raise errors.NotLocalUrl(self.transport.base)
275
517
 
276
 
    def find_branch_format(self):
 
518
    def find_branch_format(self, name=None):
277
519
        """Find the branch 'format' for this bzrdir.
278
520
 
279
521
        This might be a synthetic object for e.g. RemoteBranch and SVN.
280
522
        """
281
 
        b = self.open_branch()
 
523
        b = self.open_branch(name=name)
282
524
        return b._format
283
525
 
284
 
    def get_branch_reference(self):
 
526
    def get_branch_reference(self, name=None):
285
527
        """See BzrDir.get_branch_reference()."""
 
528
        if name is not None:
 
529
            # XXX JRV20100304: Support opening colocated branches
 
530
            raise errors.NoColocatedBranchSupport(self)
286
531
        response = self._get_branch_reference()
287
532
        if response[0] == 'ref':
288
533
            return response[1]
319
564
            raise errors.UnexpectedSmartServerResponse(response)
320
565
        return response
321
566
 
322
 
    def _get_tree_branch(self):
 
567
    def _get_tree_branch(self, name=None):
323
568
        """See BzrDir._get_tree_branch()."""
324
 
        return None, self.open_branch()
 
569
        return None, self.open_branch(name=name)
325
570
 
326
571
    def open_branch(self, name=None, unsupported=False,
327
572
                    ignore_fallbacks=False):
442
687
        """Upgrading of remote bzrdirs is not supported yet."""
443
688
        return False
444
689
 
445
 
    def needs_format_conversion(self, format=None):
 
690
    def needs_format_conversion(self, format):
446
691
        """Upgrading of remote bzrdirs is not supported yet."""
447
 
        if format is None:
448
 
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
449
 
                % 'needs_format_conversion(format=None)')
450
692
        return False
451
693
 
452
694
    def clone(self, url, revision_id=None, force_new_repo=False,
459
701
        return RemoteBzrDirConfig(self)
460
702
 
461
703
 
462
 
class RemoteRepositoryFormat(repository.RepositoryFormat):
 
704
class RemoteRepositoryFormat(vf_repository.VersionedFileRepositoryFormat):
463
705
    """Format for repositories accessed over a _SmartClient.
464
706
 
465
707
    Instances of this repository are represented by RemoteRepository
480
722
    """
481
723
 
482
724
    _matchingbzrdir = RemoteBzrDirFormat()
 
725
    supports_full_versioned_files = True
 
726
    supports_leaving_lock = True
483
727
 
484
728
    def __init__(self):
485
 
        repository.RepositoryFormat.__init__(self)
 
729
        _mod_repository.RepositoryFormat.__init__(self)
486
730
        self._custom_format = None
487
731
        self._network_name = None
488
732
        self._creating_bzrdir = None
 
733
        self._revision_graph_can_have_wrong_parents = None
489
734
        self._supports_chks = None
490
735
        self._supports_external_lookups = None
491
736
        self._supports_tree_reference = None
 
737
        self._supports_funky_characters = None
492
738
        self._rich_root_data = None
493
739
 
494
740
    def __repr__(self):
523
769
        return self._supports_external_lookups
524
770
 
525
771
    @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
526
780
    def supports_tree_reference(self):
527
781
        if self._supports_tree_reference is None:
528
782
            self._ensure_real()
530
784
                self._custom_format.supports_tree_reference
531
785
        return self._supports_tree_reference
532
786
 
 
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
 
533
795
    def _vfs_initialize(self, a_bzrdir, shared):
534
796
        """Helper for common code in initialize."""
535
797
        if self._custom_format:
570
832
            network_name = self._network_name
571
833
        else:
572
834
            # Select the current bzrlib default and ask for that.
573
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
835
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
574
836
            reference_format = reference_bzrdir_format.repository_format
575
837
            network_name = reference_format.network_name()
576
838
        # 2) try direct creation via RPC
602
864
 
603
865
    def _ensure_real(self):
604
866
        if self._custom_format is None:
605
 
            self._custom_format = repository.network_format_registry.get(
 
867
            self._custom_format = _mod_repository.network_format_registry.get(
606
868
                self._network_name)
607
869
 
608
870
    @property
645
907
 
646
908
 
647
909
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
648
 
    bzrdir.ControlComponent):
 
910
    controldir.ControlComponent):
649
911
    """Repository accessed over rpc.
650
912
 
651
913
    For the moment most operations are performed using local transport-backed
704
966
        # transport, but I'm not sure it's worth making this method
705
967
        # optional -- mbp 2010-04-21
706
968
        return self.bzrdir.get_repository_transport(None)
707
 
        
 
969
 
708
970
    def __str__(self):
709
971
        return "%s(%s)" % (self.__class__.__name__, self.base)
710
972
 
818
1080
    def find_text_key_references(self):
819
1081
        """Find the text key references within the repository.
820
1082
 
821
 
        :return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
822
 
        revision_ids. Each altered file-ids has the exact revision_ids that
823
 
        altered it listed explicitly.
824
1083
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
825
1084
            to whether they were referred to by the inventory of the
826
1085
            revision_id that they contain. The inventory texts from all present
844
1103
        """Private method for using with old (< 1.2) servers to fallback."""
845
1104
        if revision_id is None:
846
1105
            revision_id = ''
847
 
        elif revision.is_null(revision_id):
 
1106
        elif _mod_revision.is_null(revision_id):
848
1107
            return {}
849
1108
 
850
1109
        path = self.bzrdir._path_for_remote_call(self._client)
874
1133
        return RemoteStreamSource(self, to_format)
875
1134
 
876
1135
    @needs_read_lock
 
1136
    def get_file_graph(self):
 
1137
        return graph.Graph(self.texts)
 
1138
 
 
1139
    @needs_read_lock
877
1140
    def has_revision(self, revision_id):
878
1141
        """True if this repository has a copy of the revision."""
879
1142
        # Copy of bzrlib.repository.Repository.has_revision
896
1159
    def _has_same_fallbacks(self, other_repo):
897
1160
        """Returns true if the repositories have the same fallbacks."""
898
1161
        # XXX: copied from Repository; it should be unified into a base class
899
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
 
1162
        # <https://bugs.launchpad.net/bzr/+bug/401622>
900
1163
        my_fb = self._fallback_repositories
901
1164
        other_fb = other_repo._fallback_repositories
902
1165
        if len(my_fb) != len(other_fb):
931
1194
        """See Repository.gather_stats()."""
932
1195
        path = self.bzrdir._path_for_remote_call(self._client)
933
1196
        # revid can be None to indicate no revisions, not just NULL_REVISION
934
 
        if revid is None or revision.is_null(revid):
 
1197
        if revid is None or _mod_revision.is_null(revid):
935
1198
            fmt_revid = ''
936
1199
        else:
937
1200
            fmt_revid = revid
1000
1263
    def lock_read(self):
1001
1264
        """Lock the repository for read operations.
1002
1265
 
1003
 
        :return: An object with an unlock method which will release the lock
1004
 
            obtained.
 
1266
        :return: A bzrlib.lock.LogicalLockResult.
1005
1267
        """
1006
1268
        # wrong eventually - want a local lock cache context
1007
1269
        if not self._lock_mode:
1015
1277
                repo.lock_read()
1016
1278
        else:
1017
1279
            self._lock_count += 1
1018
 
        return self
 
1280
        return lock.LogicalLockResult(self.unlock)
1019
1281
 
1020
1282
    def _remote_lock_write(self, token):
1021
1283
        path = self.bzrdir._path_for_remote_call(self._client)
1221
1483
 
1222
1484
    def get_commit_builder(self, branch, parents, config, timestamp=None,
1223
1485
                           timezone=None, committer=None, revprops=None,
1224
 
                           revision_id=None):
 
1486
                           revision_id=None, lossy=False):
1225
1487
        # FIXME: It ought to be possible to call this without immediately
1226
1488
        # triggering _ensure_real.  For now it's the easiest thing to do.
1227
1489
        self._ensure_real()
1228
1490
        real_repo = self._real_repository
1229
1491
        builder = real_repo.get_commit_builder(branch, parents,
1230
1492
                config, timestamp=timestamp, timezone=timezone,
1231
 
                committer=committer, revprops=revprops, revision_id=revision_id)
 
1493
                committer=committer, revprops=revprops,
 
1494
                revision_id=revision_id, lossy=lossy)
1232
1495
        return builder
1233
1496
 
1234
1497
    def add_fallback_repository(self, repository):
1313
1576
        return self._real_repository.make_working_trees()
1314
1577
 
1315
1578
    def refresh_data(self):
1316
 
        """Re-read any data needed to to synchronise with disk.
 
1579
        """Re-read any data needed to synchronise with disk.
1317
1580
 
1318
1581
        This method is intended to be called after another repository instance
1319
1582
        (such as one used by a smart server) has inserted data into the
1320
 
        repository. It may not be called during a write group, but may be
1321
 
        called at any other time.
 
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.
1322
1588
        """
1323
 
        if self.is_in_write_group():
1324
 
            raise errors.InternalBzrError(
1325
 
                "May not refresh_data while in a write group.")
1326
1589
        if self._real_repository is not None:
1327
1590
            self._real_repository.refresh_data()
1328
1591
 
1340
1603
        return result
1341
1604
 
1342
1605
    @needs_read_lock
1343
 
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
 
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):
1344
1610
        """Return the revision ids that other has that this does not.
1345
1611
 
1346
1612
        These are returned in topological order.
1347
1613
 
1348
1614
        revision_id: only return revision ids included by revision_id.
1349
1615
        """
1350
 
        return repository.InterRepository.get(
1351
 
            other, self).search_missing_revision_ids(revision_id, find_ghosts)
 
1616
        if symbol_versioning.deprecated_passed(revision_id):
 
1617
            symbol_versioning.warn(
 
1618
                'search_missing_revision_ids(revision_id=...) was '
 
1619
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
 
1620
                DeprecationWarning, stacklevel=2)
 
1621
            if revision_ids is not None:
 
1622
                raise AssertionError(
 
1623
                    'revision_ids is mutually exclusive with revision_id')
 
1624
            if revision_id is not None:
 
1625
                revision_ids = [revision_id]
 
1626
        inter_repo = _mod_repository.InterRepository.get(other, self)
 
1627
        return inter_repo.search_missing_revision_ids(
 
1628
            find_ghosts=find_ghosts, revision_ids=revision_ids,
 
1629
            if_present_ids=if_present_ids, limit=limit)
1352
1630
 
1353
 
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
 
1631
    def fetch(self, source, revision_id=None, find_ghosts=False,
1354
1632
            fetch_spec=None):
1355
1633
        # No base implementation to use as RemoteRepository is not a subclass
1356
1634
        # of Repository; so this is a copy of Repository.fetch().
1367
1645
            # check that last_revision is in 'from' and then return a
1368
1646
            # no-operation.
1369
1647
            if (revision_id is not None and
1370
 
                not revision.is_null(revision_id)):
 
1648
                not _mod_revision.is_null(revision_id)):
1371
1649
                self.get_revision(revision_id)
1372
1650
            return 0, []
1373
1651
        # if there is no specific appropriate InterRepository, this will get
1374
1652
        # the InterRepository base class, which raises an
1375
1653
        # IncompatibleRepositories when asked to fetch.
1376
 
        inter = repository.InterRepository.get(source, self)
1377
 
        return inter.fetch(revision_id=revision_id, pb=pb,
 
1654
        inter = _mod_repository.InterRepository.get(source, self)
 
1655
        return inter.fetch(revision_id=revision_id,
1378
1656
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1379
1657
 
1380
1658
    def create_bundle(self, target, base, fileobj, format=None):
1382
1660
        self._real_repository.create_bundle(target, base, fileobj, format)
1383
1661
 
1384
1662
    @needs_read_lock
 
1663
    @symbol_versioning.deprecated_method(
 
1664
        symbol_versioning.deprecated_in((2, 4, 0)))
1385
1665
    def get_ancestry(self, revision_id, topo_sorted=True):
1386
1666
        self._ensure_real()
1387
1667
        return self._real_repository.get_ancestry(revision_id, topo_sorted)
1604
1884
            tmpdir = osutils.mkdtemp()
1605
1885
            try:
1606
1886
                _extract_tar(tar, tmpdir)
1607
 
                tmp_bzrdir = BzrDir.open(tmpdir)
 
1887
                tmp_bzrdir = _mod_bzrdir.BzrDir.open(tmpdir)
1608
1888
                tmp_repo = tmp_bzrdir.open_repository()
1609
1889
                tmp_repo.copy_content_into(destination, revision_id)
1610
1890
            finally:
1695
1975
    def supports_rich_root(self):
1696
1976
        return self._format.rich_root_data
1697
1977
 
 
1978
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
1698
1979
    def iter_reverse_revision_history(self, revision_id):
1699
1980
        self._ensure_real()
1700
1981
        return self._real_repository.iter_reverse_revision_history(revision_id)
1721
2002
        return self._real_repository.item_keys_introduced_by(revision_ids,
1722
2003
            _files_pb=_files_pb)
1723
2004
 
1724
 
    def revision_graph_can_have_wrong_parents(self):
1725
 
        # The answer depends on the remote repo format.
1726
 
        self._ensure_real()
1727
 
        return self._real_repository.revision_graph_can_have_wrong_parents()
1728
 
 
1729
2005
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
1730
2006
        self._ensure_real()
1731
2007
        return self._real_repository._find_inconsistent_revision_parents(
1739
2015
        providers = [self._unstacked_provider]
1740
2016
        if other is not None:
1741
2017
            providers.insert(0, other)
1742
 
        providers.extend(r._make_parents_provider() for r in
1743
 
                         self._fallback_repositories)
1744
 
        return graph.StackedParentsProvider(providers)
 
2018
        return graph.StackedParentsProvider(_LazyListJoin(
 
2019
            providers, self._fallback_repositories))
1745
2020
 
1746
2021
    def _serialise_search_recipe(self, recipe):
1747
2022
        """Serialise a graph search recipe.
1755
2030
        return '\n'.join((start_keys, stop_keys, count))
1756
2031
 
1757
2032
    def _serialise_search_result(self, search_result):
1758
 
        if isinstance(search_result, graph.PendingAncestryResult):
1759
 
            parts = ['ancestry-of']
1760
 
            parts.extend(search_result.heads)
1761
 
        else:
1762
 
            recipe = search_result.get_recipe()
1763
 
            parts = [recipe[0], self._serialise_search_recipe(recipe)]
 
2033
        parts = search_result.get_network_struct()
1764
2034
        return '\n'.join(parts)
1765
2035
 
1766
2036
    def autopack(self):
1776
2046
            raise errors.UnexpectedSmartServerResponse(response)
1777
2047
 
1778
2048
 
1779
 
class RemoteStreamSink(repository.StreamSink):
 
2049
class RemoteStreamSink(vf_repository.StreamSink):
1780
2050
 
1781
2051
    def _insert_real(self, stream, src_format, resume_tokens):
1782
2052
        self.target_repo._ensure_real()
1883
2153
        self._last_substream and self._last_stream so that the stream can be
1884
2154
        resumed by _resume_stream_with_vfs.
1885
2155
        """
1886
 
                    
 
2156
 
1887
2157
        stream_iter = iter(stream)
1888
2158
        for substream_kind, substream in stream_iter:
1889
2159
            if substream_kind == 'inventory-deltas':
1892
2162
                return
1893
2163
            else:
1894
2164
                yield substream_kind, substream
1895
 
            
1896
 
 
1897
 
class RemoteStreamSource(repository.StreamSource):
 
2165
 
 
2166
 
 
2167
class RemoteStreamSource(vf_repository.StreamSource):
1898
2168
    """Stream data from a remote server."""
1899
2169
 
1900
2170
    def get_stream(self, search):
1960
2230
        candidate_verbs = [
1961
2231
            ('Repository.get_stream_1.19', (1, 19)),
1962
2232
            ('Repository.get_stream', (1, 13))]
 
2233
 
1963
2234
        found_verb = False
1964
2235
        for verb, version in candidate_verbs:
1965
2236
            if medium._is_remote_before(version):
1969
2240
                    verb, args, search_bytes)
1970
2241
            except errors.UnknownSmartMethod:
1971
2242
                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
1972
2254
            else:
1973
2255
                response_tuple, response_handler = response
1974
2256
                found_verb = True
1978
2260
        if response_tuple[0] != 'ok':
1979
2261
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1980
2262
        byte_stream = response_handler.read_streamed_body()
1981
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
 
2263
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
 
2264
            self._record_counter)
1982
2265
        if src_format.network_name() != repo._format.network_name():
1983
2266
            raise AssertionError(
1984
2267
                "Mismatched RemoteRepository and stream src %r, %r" % (
2088
2371
                                  name=name)
2089
2372
        return result
2090
2373
 
2091
 
    def initialize(self, a_bzrdir, name=None):
 
2374
    def initialize(self, a_bzrdir, name=None, repository=None):
2092
2375
        # 1) get the network name to use.
2093
2376
        if self._custom_format:
2094
2377
            network_name = self._custom_format.network_name()
2095
2378
        else:
2096
2379
            # Select the current bzrlib default and ask for that.
2097
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
2380
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
2098
2381
            reference_format = reference_bzrdir_format.get_branch_format()
2099
2382
            self._custom_format = reference_format
2100
2383
            network_name = reference_format.network_name()
2122
2405
        # Turn the response into a RemoteRepository object.
2123
2406
        format = RemoteBranchFormat(network_name=response[1])
2124
2407
        repo_format = response_tuple_to_repo_format(response[3:])
2125
 
        if response[2] == '':
2126
 
            repo_bzrdir = a_bzrdir
 
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
2127
2419
        else:
2128
 
            repo_bzrdir = RemoteBzrDir(
2129
 
                a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
2130
 
                a_bzrdir._client)
2131
 
        remote_repo = RemoteRepository(repo_bzrdir, repo_format)
 
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)
2132
2427
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2133
2428
            format=format, setup_stacking=False, name=name)
2134
2429
        # XXX: We know this is a new branch, so it must have revno 0, revid
2155
2450
        self._ensure_real()
2156
2451
        return self._custom_format.supports_set_append_revisions_only()
2157
2452
 
 
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
2158
2466
 
2159
2467
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
2160
2468
    """Branch stored on a server accessed by HPSS RPC.
2359
2667
            self._is_stacked = False
2360
2668
        else:
2361
2669
            self._is_stacked = True
2362
 
        
 
2670
 
2363
2671
    def _vfs_get_tags_bytes(self):
2364
2672
        self._ensure_real()
2365
2673
        return self._real_branch._get_tags_bytes()
2366
2674
 
 
2675
    @needs_read_lock
2367
2676
    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):
2368
2682
        medium = self._client._medium
2369
2683
        if medium._is_remote_before((1, 13)):
2370
2684
            return self._vfs_get_tags_bytes()
2380
2694
        return self._real_branch._set_tags_bytes(bytes)
2381
2695
 
2382
2696
    def _set_tags_bytes(self, bytes):
 
2697
        if self.is_locked():
 
2698
            self._tags_bytes = bytes
2383
2699
        medium = self._client._medium
2384
2700
        if medium._is_remote_before((1, 18)):
2385
2701
            self._vfs_set_tags_bytes(bytes)
2396
2712
    def lock_read(self):
2397
2713
        """Lock the branch for read operations.
2398
2714
 
2399
 
        :return: An object with an unlock method which will release the lock
2400
 
            obtained.
 
2715
        :return: A bzrlib.lock.LogicalLockResult.
2401
2716
        """
2402
2717
        self.repository.lock_read()
2403
2718
        if not self._lock_mode:
2408
2723
                self._real_branch.lock_read()
2409
2724
        else:
2410
2725
            self._lock_count += 1
2411
 
        return self
 
2726
        return lock.LogicalLockResult(self.unlock)
2412
2727
 
2413
2728
    def _remote_lock_write(self, token):
2414
2729
        if token is None:
2418
2733
            repo_token = self.repository.lock_write().repository_token
2419
2734
            self.repository.unlock()
2420
2735
        err_context = {'token': token}
2421
 
        response = self._call(
2422
 
            'Branch.lock_write', self._remote_path(), branch_token,
2423
 
            repo_token or '', **err_context)
 
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])
2424
2746
        if response[0] != 'ok':
2425
2747
            raise errors.UnexpectedSmartServerResponse(response)
2426
2748
        ok, branch_token, repo_token = response
2447
2769
            self._lock_mode = 'w'
2448
2770
            self._lock_count = 1
2449
2771
        elif self._lock_mode == 'r':
2450
 
            raise errors.ReadOnlyTransaction
 
2772
            raise errors.ReadOnlyError(self)
2451
2773
        else:
2452
2774
            if token is not None:
2453
2775
                # A token was given to lock_write, and we're relocking, so
2533
2855
            missing_parent = parent_map[missing_parent]
2534
2856
        raise errors.RevisionNotPresent(missing_parent, self.repository)
2535
2857
 
2536
 
    def _last_revision_info(self):
 
2858
    def _read_last_revision_info(self):
2537
2859
        response = self._call('Branch.last_revision_info', self._remote_path())
2538
2860
        if response[0] != 'ok':
2539
2861
            raise SmartProtocolError('unexpected response code %s' % (response,))
2602
2924
            raise errors.UnexpectedSmartServerResponse(response)
2603
2925
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2604
2926
 
 
2927
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2605
2928
    @needs_write_lock
2606
2929
    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):
2607
2935
        # Send just the tip revision of the history; the server will generate
2608
2936
        # the full history from that.  If the revision doesn't exist in this
2609
2937
        # branch, NoSuchRevision will be raised.
2667
2995
            _override_hook_target=self, **kwargs)
2668
2996
 
2669
2997
    @needs_read_lock
2670
 
    def push(self, target, overwrite=False, stop_revision=None):
 
2998
    def push(self, target, overwrite=False, stop_revision=None, lossy=False):
2671
2999
        self._ensure_real()
2672
3000
        return self._real_branch.push(
2673
 
            target, overwrite=overwrite, stop_revision=stop_revision,
 
3001
            target, overwrite=overwrite, stop_revision=stop_revision, lossy=lossy,
2674
3002
            _override_hook_source_branch=self)
2675
3003
 
2676
3004
    def is_locked(self):
2686
3014
        # XXX: These should be returned by the set_last_revision_info verb
2687
3015
        old_revno, old_revid = self.last_revision_info()
2688
3016
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
2689
 
        revision_id = ensure_null(revision_id)
 
3017
        if not revision_id or not isinstance(revision_id, basestring):
 
3018
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2690
3019
        try:
2691
3020
            response = self._call('Branch.set_last_revision_info',
2692
3021
                self._remote_path(), self._lock_token, self._repo_lock_token,
2721
3050
            except errors.UnknownSmartMethod:
2722
3051
                medium._remember_remote_is_before((1, 6))
2723
3052
        self._clear_cached_state_of_remote_branch_only()
2724
 
        self.set_revision_history(self._lefthand_history(revision_id,
 
3053
        self._set_revision_history(self._lefthand_history(revision_id,
2725
3054
            last_rev=last_rev,other_branch=other_branch))
2726
3055
 
2727
3056
    def set_push_location(self, location):
2728
3057
        self._ensure_real()
2729
3058
        return self._real_branch.set_push_location(location)
2730
3059
 
 
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
 
2731
3087
 
2732
3088
class RemoteConfig(object):
2733
3089
    """A Config that reads and writes from smart verbs.
2747
3103
        """
2748
3104
        try:
2749
3105
            configobj = self._get_configobj()
 
3106
            section_obj = None
2750
3107
            if section is None:
2751
3108
                section_obj = configobj
2752
3109
            else:
2753
3110
                try:
2754
3111
                    section_obj = configobj[section]
2755
3112
                except KeyError:
2756
 
                    return default
2757
 
            return section_obj.get(name, default)
 
3113
                    pass
 
3114
            if section_obj is None:
 
3115
                value = default
 
3116
            else:
 
3117
                value = section_obj.get(name, default)
2758
3118
        except errors.UnknownSmartMethod:
2759
 
            return self._vfs_get_option(name, section, default)
 
3119
            value = self._vfs_get_option(name, section, default)
 
3120
        for hook in config.OldConfigHooks['get']:
 
3121
            hook(self, name, value)
 
3122
        return value
2760
3123
 
2761
3124
    def _response_to_configobj(self, response):
2762
3125
        if len(response[0]) and response[0][0] != 'ok':
2763
3126
            raise errors.UnexpectedSmartServerResponse(response)
2764
3127
        lines = response[1].read_body_bytes().splitlines()
2765
 
        return config.ConfigObj(lines, encoding='utf-8')
 
3128
        conf = config.ConfigObj(lines, encoding='utf-8')
 
3129
        for hook in config.OldConfigHooks['load']:
 
3130
            hook(self)
 
3131
        return conf
2766
3132
 
2767
3133
 
2768
3134
class RemoteBranchConfig(RemoteConfig):
2787
3153
        medium = self._branch._client._medium
2788
3154
        if medium._is_remote_before((1, 14)):
2789
3155
            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):
2790
3164
        try:
2791
3165
            path = self._branch._remote_path()
2792
3166
            response = self._branch._client.call('Branch.set_config_option',
2793
3167
                path, self._branch._lock_token, self._branch._repo_lock_token,
2794
3168
                value.encode('utf8'), name, section or '')
2795
3169
        except errors.UnknownSmartMethod:
 
3170
            medium = self._branch._client._medium
2796
3171
            medium._remember_remote_is_before((1, 14))
2797
3172
            return self._vfs_set_option(value, name, section)
2798
3173
        if response != ():
2799
3174
            raise errors.UnexpectedSmartServerResponse(response)
2800
3175
 
 
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
 
2801
3201
    def _real_object(self):
2802
3202
        self._branch._ensure_real()
2803
3203
        return self._branch._real_branch
2886
3286
                    'Missing key %r in context %r', key_err.args[0], context)
2887
3287
                raise err
2888
3288
 
2889
 
    if err.error_verb == 'IncompatibleRepositories':
2890
 
        raise errors.IncompatibleRepositories(err.error_args[0],
2891
 
            err.error_args[1], err.error_args[2])
2892
 
    elif err.error_verb == 'NoSuchRevision':
 
3289
    if err.error_verb == 'NoSuchRevision':
2893
3290
        raise NoSuchRevision(find('branch'), err.error_args[0])
2894
3291
    elif err.error_verb == 'nosuchrevision':
2895
3292
        raise NoSuchRevision(find('repository'), err.error_args[0])
2902
3299
            detail=extra)
2903
3300
    elif err.error_verb == 'norepository':
2904
3301
        raise errors.NoRepositoryPresent(find('bzrdir'))
2905
 
    elif err.error_verb == 'LockContention':
2906
 
        raise errors.LockContention('(remote lock)')
2907
3302
    elif err.error_verb == 'UnlockableTransport':
2908
3303
        raise errors.UnlockableTransport(find('bzrdir').root_transport)
2909
 
    elif err.error_verb == 'LockFailed':
2910
 
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
2911
3304
    elif err.error_verb == 'TokenMismatch':
2912
3305
        raise errors.TokenMismatch(find('token'), '(remote token)')
2913
3306
    elif err.error_verb == 'Diverged':
2914
3307
        raise errors.DivergedBranches(find('branch'), find('other_branch'))
2915
 
    elif err.error_verb == 'TipChangeRejected':
2916
 
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
2917
 
    elif err.error_verb == 'UnstackableBranchFormat':
2918
 
        raise errors.UnstackableBranchFormat(*err.error_args)
2919
 
    elif err.error_verb == 'UnstackableRepositoryFormat':
2920
 
        raise errors.UnstackableRepositoryFormat(*err.error_args)
2921
3308
    elif err.error_verb == 'NotStacked':
2922
3309
        raise errors.NotStacked(branch=find('branch'))
2923
3310
    elif err.error_verb == 'PermissionDenied':
2933
3320
    elif err.error_verb == 'NoSuchFile':
2934
3321
        path = get_path()
2935
3322
        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)
2936
3341
    elif err.error_verb == 'FileExists':
2937
3342
        raise errors.FileExists(err.error_args[0])
2938
3343
    elif err.error_verb == 'DirectoryNotEmpty':
2957
3362
            raise UnicodeEncodeError(encoding, val, start, end, reason)
2958
3363
    elif err.error_verb == 'ReadOnlyError':
2959
3364
        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.")
2960
3368
    raise errors.UnknownErrorFromSmartServer(err)