/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: Jelmer Vernooij
  • Date: 2011-05-02 17:07:16 UTC
  • mto: This revision was merged to the branch mainline in revision 5844.
  • Revision ID: jelmer@samba.org-20110502170716-mp5l2k4l4m5b3cw6
split out versionedfile-specific stuff from commitbuilder.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
19
19
from bzrlib import (
20
20
    bencode,
21
21
    branch,
22
 
    bzrdir,
 
22
    bzrdir as _mod_bzrdir,
23
23
    config,
 
24
    controldir,
24
25
    debug,
25
26
    errors,
26
27
    graph,
27
28
    lock,
28
29
    lockdir,
29
 
    repository,
30
30
    repository as _mod_repository,
31
 
    revision,
32
31
    revision as _mod_revision,
33
32
    static_tuple,
34
33
    symbol_versioning,
35
 
)
36
 
from bzrlib.branch import BranchReferenceFormat
37
 
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
 
34
    urlutils,
 
35
    vf_repository,
 
36
    )
 
37
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
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
 
45
from bzrlib.smart.client import _SmartClient
 
46
from bzrlib.revision import NULL_REVISION
 
47
from bzrlib.repository import RepositoryWriteLockResult
46
48
from bzrlib.trace import mutter, note, warning
47
49
 
48
50
 
86
88
    return format
87
89
 
88
90
 
89
 
# Note: RemoteBzrDirFormat is in bzrdir.py
90
 
 
91
 
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):
92
331
    """Control directory on a remote server, accessed via bzr:// or similar."""
93
332
 
94
333
    def __init__(self, transport, format, _client=None, _force_probe=False):
97
336
        :param _client: Private parameter for testing. Disables probing and the
98
337
            use of a real bzrdir.
99
338
        """
100
 
        BzrDir.__init__(self, transport, format)
 
339
        _mod_bzrdir.BzrDir.__init__(self, transport, format)
101
340
        # this object holds a delegated bzrdir that uses file-level operations
102
341
        # to talk to the other side
103
342
        self._real_bzrdir = None
163
402
                import traceback
164
403
                warning('VFS BzrDir access triggered\n%s',
165
404
                    ''.join(traceback.format_stack()))
166
 
            self._real_bzrdir = BzrDir.open_from_transport(
 
405
            self._real_bzrdir = _mod_bzrdir.BzrDir.open_from_transport(
167
406
                self.root_transport, _server_formats=False)
168
407
            self._format._network_name = \
169
408
                self._real_bzrdir._format.network_name()
175
414
        # Prevent aliasing problems in the next_open_branch_result cache.
176
415
        # See create_branch for rationale.
177
416
        self._next_open_branch_result = None
178
 
        return BzrDir.break_lock(self)
 
417
        return _mod_bzrdir.BzrDir.break_lock(self)
179
418
 
180
419
    def _vfs_cloning_metadir(self, require_stacking=False):
181
420
        self._ensure_real()
212
451
        if len(branch_info) != 2:
213
452
            raise errors.UnexpectedSmartServerResponse(response)
214
453
        branch_ref, branch_name = branch_info
215
 
        format = bzrdir.network_format_registry.get(control_name)
 
454
        format = controldir.network_format_registry.get(control_name)
216
455
        if repo_name:
217
 
            format.repository_format = repository.network_format_registry.get(
 
456
            format.repository_format = _mod_repository.network_format_registry.get(
218
457
                repo_name)
219
458
        if branch_ref == 'ref':
220
459
            # XXX: we need possible_transports here to avoid reopening the
221
460
            # connection to the referenced location
222
 
            ref_bzrdir = BzrDir.open(branch_name)
 
461
            ref_bzrdir = _mod_bzrdir.BzrDir.open(branch_name)
223
462
            branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
224
463
            format.set_branch_format(branch_format)
225
464
        elif branch_ref == 'branch':
244
483
        self._ensure_real()
245
484
        self._real_bzrdir.destroy_repository()
246
485
 
247
 
    def create_branch(self, name=None):
 
486
    def create_branch(self, name=None, repository=None):
248
487
        # as per meta1 formats - just delegate to the format object which may
249
488
        # be parameterised.
250
489
        real_branch = self._format.get_branch_format().initialize(self,
251
 
            name=name)
 
490
            name=name, repository=repository)
252
491
        if not isinstance(real_branch, RemoteBranch):
253
 
            result = RemoteBranch(self, self.find_repository(), real_branch,
254
 
                                  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)
255
497
        else:
256
498
            result = real_branch
257
499
        # BzrDir.clone_on_transport() uses the result of create_branch but does
269
511
        self._real_bzrdir.destroy_branch(name=name)
270
512
        self._next_open_branch_result = None
271
513
 
272
 
    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):
273
516
        raise errors.NotLocalUrl(self.transport.base)
274
517
 
275
 
    def find_branch_format(self):
 
518
    def find_branch_format(self, name=None):
276
519
        """Find the branch 'format' for this bzrdir.
277
520
 
278
521
        This might be a synthetic object for e.g. RemoteBranch and SVN.
279
522
        """
280
 
        b = self.open_branch()
 
523
        b = self.open_branch(name=name)
281
524
        return b._format
282
525
 
283
 
    def get_branch_reference(self):
 
526
    def get_branch_reference(self, name=None):
284
527
        """See BzrDir.get_branch_reference()."""
 
528
        if name is not None:
 
529
            # XXX JRV20100304: Support opening colocated branches
 
530
            raise errors.NoColocatedBranchSupport(self)
285
531
        response = self._get_branch_reference()
286
532
        if response[0] == 'ref':
287
533
            return response[1]
318
564
            raise errors.UnexpectedSmartServerResponse(response)
319
565
        return response
320
566
 
321
 
    def _get_tree_branch(self):
 
567
    def _get_tree_branch(self, name=None):
322
568
        """See BzrDir._get_tree_branch()."""
323
 
        return None, self.open_branch()
 
569
        return None, self.open_branch(name=name)
324
570
 
325
571
    def open_branch(self, name=None, unsupported=False,
326
572
                    ignore_fallbacks=False):
441
687
        """Upgrading of remote bzrdirs is not supported yet."""
442
688
        return False
443
689
 
444
 
    def needs_format_conversion(self, format=None):
 
690
    def needs_format_conversion(self, format):
445
691
        """Upgrading of remote bzrdirs is not supported yet."""
446
 
        if format is None:
447
 
            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))
448
 
                % 'needs_format_conversion(format=None)')
449
692
        return False
450
693
 
451
694
    def clone(self, url, revision_id=None, force_new_repo=False,
458
701
        return RemoteBzrDirConfig(self)
459
702
 
460
703
 
461
 
class RemoteRepositoryFormat(repository.RepositoryFormat):
 
704
class RemoteRepositoryFormat(_mod_repository.RepositoryFormat):
462
705
    """Format for repositories accessed over a _SmartClient.
463
706
 
464
707
    Instances of this repository are represented by RemoteRepository
479
722
    """
480
723
 
481
724
    _matchingbzrdir = RemoteBzrDirFormat()
 
725
    supports_full_versioned_files = True
 
726
    supports_leaving_lock = True
482
727
 
483
728
    def __init__(self):
484
 
        repository.RepositoryFormat.__init__(self)
 
729
        _mod_repository.RepositoryFormat.__init__(self)
485
730
        self._custom_format = None
486
731
        self._network_name = None
487
732
        self._creating_bzrdir = None
 
733
        self._revision_graph_can_have_wrong_parents = None
488
734
        self._supports_chks = None
489
735
        self._supports_external_lookups = None
490
736
        self._supports_tree_reference = None
 
737
        self._supports_funky_characters = None
491
738
        self._rich_root_data = None
492
739
 
493
740
    def __repr__(self):
522
769
        return self._supports_external_lookups
523
770
 
524
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
525
780
    def supports_tree_reference(self):
526
781
        if self._supports_tree_reference is None:
527
782
            self._ensure_real()
529
784
                self._custom_format.supports_tree_reference
530
785
        return self._supports_tree_reference
531
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
 
532
795
    def _vfs_initialize(self, a_bzrdir, shared):
533
796
        """Helper for common code in initialize."""
534
797
        if self._custom_format:
569
832
            network_name = self._network_name
570
833
        else:
571
834
            # Select the current bzrlib default and ask for that.
572
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
835
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
573
836
            reference_format = reference_bzrdir_format.repository_format
574
837
            network_name = reference_format.network_name()
575
838
        # 2) try direct creation via RPC
601
864
 
602
865
    def _ensure_real(self):
603
866
        if self._custom_format is None:
604
 
            self._custom_format = repository.network_format_registry.get(
 
867
            self._custom_format = _mod_repository.network_format_registry.get(
605
868
                self._network_name)
606
869
 
607
870
    @property
644
907
 
645
908
 
646
909
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
647
 
    bzrdir.ControlComponent):
 
910
    controldir.ControlComponent):
648
911
    """Repository accessed over rpc.
649
912
 
650
913
    For the moment most operations are performed using local transport-backed
703
966
        # transport, but I'm not sure it's worth making this method
704
967
        # optional -- mbp 2010-04-21
705
968
        return self.bzrdir.get_repository_transport(None)
706
 
        
 
969
 
707
970
    def __str__(self):
708
971
        return "%s(%s)" % (self.__class__.__name__, self.base)
709
972
 
843
1106
        """Private method for using with old (< 1.2) servers to fallback."""
844
1107
        if revision_id is None:
845
1108
            revision_id = ''
846
 
        elif revision.is_null(revision_id):
 
1109
        elif _mod_revision.is_null(revision_id):
847
1110
            return {}
848
1111
 
849
1112
        path = self.bzrdir._path_for_remote_call(self._client)
895
1158
    def _has_same_fallbacks(self, other_repo):
896
1159
        """Returns true if the repositories have the same fallbacks."""
897
1160
        # XXX: copied from Repository; it should be unified into a base class
898
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
 
1161
        # <https://bugs.launchpad.net/bzr/+bug/401622>
899
1162
        my_fb = self._fallback_repositories
900
1163
        other_fb = other_repo._fallback_repositories
901
1164
        if len(my_fb) != len(other_fb):
930
1193
        """See Repository.gather_stats()."""
931
1194
        path = self.bzrdir._path_for_remote_call(self._client)
932
1195
        # revid can be None to indicate no revisions, not just NULL_REVISION
933
 
        if revid is None or revision.is_null(revid):
 
1196
        if revid is None or _mod_revision.is_null(revid):
934
1197
            fmt_revid = ''
935
1198
        else:
936
1199
            fmt_revid = revid
997
1260
        pass
998
1261
 
999
1262
    def lock_read(self):
 
1263
        """Lock the repository for read operations.
 
1264
 
 
1265
        :return: A bzrlib.lock.LogicalLockResult.
 
1266
        """
1000
1267
        # wrong eventually - want a local lock cache context
1001
1268
        if not self._lock_mode:
1002
1269
            self._note_lock('r')
1009
1276
                repo.lock_read()
1010
1277
        else:
1011
1278
            self._lock_count += 1
 
1279
        return lock.LogicalLockResult(self.unlock)
1012
1280
 
1013
1281
    def _remote_lock_write(self, token):
1014
1282
        path = self.bzrdir._path_for_remote_call(self._client)
1054
1322
            raise errors.ReadOnlyError(self)
1055
1323
        else:
1056
1324
            self._lock_count += 1
1057
 
        return self._lock_token or None
 
1325
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
1058
1326
 
1059
1327
    def leave_lock_in_place(self):
1060
1328
        if not self._lock_token:
1214
1482
 
1215
1483
    def get_commit_builder(self, branch, parents, config, timestamp=None,
1216
1484
                           timezone=None, committer=None, revprops=None,
1217
 
                           revision_id=None):
 
1485
                           revision_id=None, lossy=False):
1218
1486
        # FIXME: It ought to be possible to call this without immediately
1219
1487
        # triggering _ensure_real.  For now it's the easiest thing to do.
1220
1488
        self._ensure_real()
1221
1489
        real_repo = self._real_repository
1222
1490
        builder = real_repo.get_commit_builder(branch, parents,
1223
1491
                config, timestamp=timestamp, timezone=timezone,
1224
 
                committer=committer, revprops=revprops, revision_id=revision_id)
 
1492
                committer=committer, revprops=revprops,
 
1493
                revision_id=revision_id, lossy=lossy)
1225
1494
        return builder
1226
1495
 
1227
1496
    def add_fallback_repository(self, repository):
1306
1575
        return self._real_repository.make_working_trees()
1307
1576
 
1308
1577
    def refresh_data(self):
1309
 
        """Re-read any data needed to to synchronise with disk.
 
1578
        """Re-read any data needed to synchronise with disk.
1310
1579
 
1311
1580
        This method is intended to be called after another repository instance
1312
1581
        (such as one used by a smart server) has inserted data into the
1313
 
        repository. It may not be called during a write group, but may be
1314
 
        called at any other time.
 
1582
        repository. On all repositories this will work outside of write groups.
 
1583
        Some repository formats (pack and newer for bzrlib native formats)
 
1584
        support refresh_data inside write groups. If called inside a write
 
1585
        group on a repository that does not support refreshing in a write group
 
1586
        IsInWriteGroupError will be raised.
1315
1587
        """
1316
 
        if self.is_in_write_group():
1317
 
            raise errors.InternalBzrError(
1318
 
                "May not refresh_data while in a write group.")
1319
1588
        if self._real_repository is not None:
1320
1589
            self._real_repository.refresh_data()
1321
1590
 
1333
1602
        return result
1334
1603
 
1335
1604
    @needs_read_lock
1336
 
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
 
1605
    def search_missing_revision_ids(self, other,
 
1606
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
 
1607
            find_ghosts=True, revision_ids=None, if_present_ids=None):
1337
1608
        """Return the revision ids that other has that this does not.
1338
1609
 
1339
1610
        These are returned in topological order.
1340
1611
 
1341
1612
        revision_id: only return revision ids included by revision_id.
1342
1613
        """
1343
 
        return repository.InterRepository.get(
1344
 
            other, self).search_missing_revision_ids(revision_id, find_ghosts)
 
1614
        if symbol_versioning.deprecated_passed(revision_id):
 
1615
            symbol_versioning.warn(
 
1616
                'search_missing_revision_ids(revision_id=...) was '
 
1617
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
 
1618
                DeprecationWarning, stacklevel=2)
 
1619
            if revision_ids is not None:
 
1620
                raise AssertionError(
 
1621
                    'revision_ids is mutually exclusive with revision_id')
 
1622
            if revision_id is not None:
 
1623
                revision_ids = [revision_id]
 
1624
        inter_repo = _mod_repository.InterRepository.get(other, self)
 
1625
        return inter_repo.search_missing_revision_ids(
 
1626
            find_ghosts=find_ghosts, revision_ids=revision_ids,
 
1627
            if_present_ids=if_present_ids)
1345
1628
 
1346
 
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
 
1629
    def fetch(self, source, revision_id=None, find_ghosts=False,
1347
1630
            fetch_spec=None):
1348
1631
        # No base implementation to use as RemoteRepository is not a subclass
1349
1632
        # of Repository; so this is a copy of Repository.fetch().
1360
1643
            # check that last_revision is in 'from' and then return a
1361
1644
            # no-operation.
1362
1645
            if (revision_id is not None and
1363
 
                not revision.is_null(revision_id)):
 
1646
                not _mod_revision.is_null(revision_id)):
1364
1647
                self.get_revision(revision_id)
1365
1648
            return 0, []
1366
1649
        # if there is no specific appropriate InterRepository, this will get
1367
1650
        # the InterRepository base class, which raises an
1368
1651
        # IncompatibleRepositories when asked to fetch.
1369
 
        inter = repository.InterRepository.get(source, self)
1370
 
        return inter.fetch(revision_id=revision_id, pb=pb,
 
1652
        inter = _mod_repository.InterRepository.get(source, self)
 
1653
        return inter.fetch(revision_id=revision_id,
1371
1654
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1372
1655
 
1373
1656
    def create_bundle(self, target, base, fileobj, format=None):
1597
1880
            tmpdir = osutils.mkdtemp()
1598
1881
            try:
1599
1882
                _extract_tar(tar, tmpdir)
1600
 
                tmp_bzrdir = BzrDir.open(tmpdir)
 
1883
                tmp_bzrdir = _mod_bzrdir.BzrDir.open(tmpdir)
1601
1884
                tmp_repo = tmp_bzrdir.open_repository()
1602
1885
                tmp_repo.copy_content_into(destination, revision_id)
1603
1886
            finally:
1714
1997
        return self._real_repository.item_keys_introduced_by(revision_ids,
1715
1998
            _files_pb=_files_pb)
1716
1999
 
1717
 
    def revision_graph_can_have_wrong_parents(self):
1718
 
        # The answer depends on the remote repo format.
1719
 
        self._ensure_real()
1720
 
        return self._real_repository.revision_graph_can_have_wrong_parents()
1721
 
 
1722
2000
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
1723
2001
        self._ensure_real()
1724
2002
        return self._real_repository._find_inconsistent_revision_parents(
1748
2026
        return '\n'.join((start_keys, stop_keys, count))
1749
2027
 
1750
2028
    def _serialise_search_result(self, search_result):
1751
 
        if isinstance(search_result, graph.PendingAncestryResult):
1752
 
            parts = ['ancestry-of']
1753
 
            parts.extend(search_result.heads)
1754
 
        else:
1755
 
            recipe = search_result.get_recipe()
1756
 
            parts = [recipe[0], self._serialise_search_recipe(recipe)]
 
2029
        parts = search_result.get_network_struct()
1757
2030
        return '\n'.join(parts)
1758
2031
 
1759
2032
    def autopack(self):
1769
2042
            raise errors.UnexpectedSmartServerResponse(response)
1770
2043
 
1771
2044
 
1772
 
class RemoteStreamSink(repository.StreamSink):
 
2045
class RemoteStreamSink(vf_repository.StreamSink):
1773
2046
 
1774
2047
    def _insert_real(self, stream, src_format, resume_tokens):
1775
2048
        self.target_repo._ensure_real()
1876
2149
        self._last_substream and self._last_stream so that the stream can be
1877
2150
        resumed by _resume_stream_with_vfs.
1878
2151
        """
1879
 
                    
 
2152
 
1880
2153
        stream_iter = iter(stream)
1881
2154
        for substream_kind, substream in stream_iter:
1882
2155
            if substream_kind == 'inventory-deltas':
1885
2158
                return
1886
2159
            else:
1887
2160
                yield substream_kind, substream
1888
 
            
1889
 
 
1890
 
class RemoteStreamSource(repository.StreamSource):
 
2161
 
 
2162
 
 
2163
class RemoteStreamSource(vf_repository.StreamSource):
1891
2164
    """Stream data from a remote server."""
1892
2165
 
1893
2166
    def get_stream(self, search):
1953
2226
        candidate_verbs = [
1954
2227
            ('Repository.get_stream_1.19', (1, 19)),
1955
2228
            ('Repository.get_stream', (1, 13))]
 
2229
 
1956
2230
        found_verb = False
1957
2231
        for verb, version in candidate_verbs:
1958
2232
            if medium._is_remote_before(version):
1962
2236
                    verb, args, search_bytes)
1963
2237
            except errors.UnknownSmartMethod:
1964
2238
                medium._remember_remote_is_before(version)
 
2239
            except errors.UnknownErrorFromSmartServer, e:
 
2240
                if isinstance(search, graph.EverythingResult):
 
2241
                    error_verb = e.error_from_smart_server.error_verb
 
2242
                    if error_verb == 'BadSearch':
 
2243
                        # Pre-2.4 servers don't support this sort of search.
 
2244
                        # XXX: perhaps falling back to VFS on BadSearch is a
 
2245
                        # good idea in general?  It might provide a little bit
 
2246
                        # of protection against client-side bugs.
 
2247
                        medium._remember_remote_is_before((2, 4))
 
2248
                        break
 
2249
                raise
1965
2250
            else:
1966
2251
                response_tuple, response_handler = response
1967
2252
                found_verb = True
1971
2256
        if response_tuple[0] != 'ok':
1972
2257
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1973
2258
        byte_stream = response_handler.read_streamed_body()
1974
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
 
2259
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
 
2260
            self._record_counter)
1975
2261
        if src_format.network_name() != repo._format.network_name():
1976
2262
            raise AssertionError(
1977
2263
                "Mismatched RemoteRepository and stream src %r, %r" % (
2081
2367
                                  name=name)
2082
2368
        return result
2083
2369
 
2084
 
    def initialize(self, a_bzrdir, name=None):
 
2370
    def initialize(self, a_bzrdir, name=None, repository=None):
2085
2371
        # 1) get the network name to use.
2086
2372
        if self._custom_format:
2087
2373
            network_name = self._custom_format.network_name()
2088
2374
        else:
2089
2375
            # Select the current bzrlib default and ask for that.
2090
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
2376
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
2091
2377
            reference_format = reference_bzrdir_format.get_branch_format()
2092
2378
            self._custom_format = reference_format
2093
2379
            network_name = reference_format.network_name()
2115
2401
        # Turn the response into a RemoteRepository object.
2116
2402
        format = RemoteBranchFormat(network_name=response[1])
2117
2403
        repo_format = response_tuple_to_repo_format(response[3:])
2118
 
        if response[2] == '':
2119
 
            repo_bzrdir = a_bzrdir
 
2404
        repo_path = response[2]
 
2405
        if repository is not None:
 
2406
            remote_repo_url = urlutils.join(a_bzrdir.user_url, repo_path)
 
2407
            url_diff = urlutils.relative_url(repository.user_url,
 
2408
                    remote_repo_url)
 
2409
            if url_diff != '.':
 
2410
                raise AssertionError(
 
2411
                    'repository.user_url %r does not match URL from server '
 
2412
                    'response (%r + %r)'
 
2413
                    % (repository.user_url, a_bzrdir.user_url, repo_path))
 
2414
            remote_repo = repository
2120
2415
        else:
2121
 
            repo_bzrdir = RemoteBzrDir(
2122
 
                a_bzrdir.root_transport.clone(response[2]), a_bzrdir._format,
2123
 
                a_bzrdir._client)
2124
 
        remote_repo = RemoteRepository(repo_bzrdir, repo_format)
 
2416
            if repo_path == '':
 
2417
                repo_bzrdir = a_bzrdir
 
2418
            else:
 
2419
                repo_bzrdir = RemoteBzrDir(
 
2420
                    a_bzrdir.root_transport.clone(repo_path), a_bzrdir._format,
 
2421
                    a_bzrdir._client)
 
2422
            remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2125
2423
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2126
2424
            format=format, setup_stacking=False, name=name)
2127
2425
        # XXX: We know this is a new branch, so it must have revno 0, revid
2148
2446
        self._ensure_real()
2149
2447
        return self._custom_format.supports_set_append_revisions_only()
2150
2448
 
 
2449
    def _use_default_local_heads_to_fetch(self):
 
2450
        # If the branch format is a metadir format *and* its heads_to_fetch
 
2451
        # implementation is not overridden vs the base class, we can use the
 
2452
        # base class logic rather than use the heads_to_fetch RPC.  This is
 
2453
        # usually cheaper in terms of net round trips, as the last-revision and
 
2454
        # tags info fetched is cached and would be fetched anyway.
 
2455
        self._ensure_real()
 
2456
        if isinstance(self._custom_format, branch.BranchFormatMetadir):
 
2457
            branch_class = self._custom_format._branch_class()
 
2458
            heads_to_fetch_impl = branch_class.heads_to_fetch.im_func
 
2459
            if heads_to_fetch_impl is branch.Branch.heads_to_fetch.im_func:
 
2460
                return True
 
2461
        return False
2151
2462
 
2152
2463
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
2153
2464
    """Branch stored on a server accessed by HPSS RPC.
2352
2663
            self._is_stacked = False
2353
2664
        else:
2354
2665
            self._is_stacked = True
2355
 
        
 
2666
 
2356
2667
    def _vfs_get_tags_bytes(self):
2357
2668
        self._ensure_real()
2358
2669
        return self._real_branch._get_tags_bytes()
2359
2670
 
 
2671
    @needs_read_lock
2360
2672
    def _get_tags_bytes(self):
 
2673
        if self._tags_bytes is None:
 
2674
            self._tags_bytes = self._get_tags_bytes_via_hpss()
 
2675
        return self._tags_bytes
 
2676
 
 
2677
    def _get_tags_bytes_via_hpss(self):
2361
2678
        medium = self._client._medium
2362
2679
        if medium._is_remote_before((1, 13)):
2363
2680
            return self._vfs_get_tags_bytes()
2373
2690
        return self._real_branch._set_tags_bytes(bytes)
2374
2691
 
2375
2692
    def _set_tags_bytes(self, bytes):
 
2693
        if self.is_locked():
 
2694
            self._tags_bytes = bytes
2376
2695
        medium = self._client._medium
2377
2696
        if medium._is_remote_before((1, 18)):
2378
2697
            self._vfs_set_tags_bytes(bytes)
2387
2706
            self._vfs_set_tags_bytes(bytes)
2388
2707
 
2389
2708
    def lock_read(self):
 
2709
        """Lock the branch for read operations.
 
2710
 
 
2711
        :return: A bzrlib.lock.LogicalLockResult.
 
2712
        """
2390
2713
        self.repository.lock_read()
2391
2714
        if not self._lock_mode:
2392
2715
            self._note_lock('r')
2396
2719
                self._real_branch.lock_read()
2397
2720
        else:
2398
2721
            self._lock_count += 1
 
2722
        return lock.LogicalLockResult(self.unlock)
2399
2723
 
2400
2724
    def _remote_lock_write(self, token):
2401
2725
        if token is None:
2402
2726
            branch_token = repo_token = ''
2403
2727
        else:
2404
2728
            branch_token = token
2405
 
            repo_token = self.repository.lock_write()
 
2729
            repo_token = self.repository.lock_write().repository_token
2406
2730
            self.repository.unlock()
2407
2731
        err_context = {'token': token}
2408
 
        response = self._call(
2409
 
            'Branch.lock_write', self._remote_path(), branch_token,
2410
 
            repo_token or '', **err_context)
 
2732
        try:
 
2733
            response = self._call(
 
2734
                'Branch.lock_write', self._remote_path(), branch_token,
 
2735
                repo_token or '', **err_context)
 
2736
        except errors.LockContention, e:
 
2737
            # The LockContention from the server doesn't have any
 
2738
            # information about the lock_url. We re-raise LockContention
 
2739
            # with valid lock_url.
 
2740
            raise errors.LockContention('(remote lock)',
 
2741
                self.repository.base.split('.bzr/')[0])
2411
2742
        if response[0] != 'ok':
2412
2743
            raise errors.UnexpectedSmartServerResponse(response)
2413
2744
        ok, branch_token, repo_token = response
2434
2765
            self._lock_mode = 'w'
2435
2766
            self._lock_count = 1
2436
2767
        elif self._lock_mode == 'r':
2437
 
            raise errors.ReadOnlyTransaction
 
2768
            raise errors.ReadOnlyError(self)
2438
2769
        else:
2439
2770
            if token is not None:
2440
2771
                # A token was given to lock_write, and we're relocking, so
2445
2776
            self._lock_count += 1
2446
2777
            # Re-lock the repository too.
2447
2778
            self.repository.lock_write(self._repo_lock_token)
2448
 
        return self._lock_token or None
 
2779
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
2449
2780
 
2450
2781
    def _unlock(self, branch_token, repo_token):
2451
2782
        err_context = {'token': str((branch_token, repo_token))}
2589
2920
            raise errors.UnexpectedSmartServerResponse(response)
2590
2921
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2591
2922
 
 
2923
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2592
2924
    @needs_write_lock
2593
2925
    def set_revision_history(self, rev_history):
 
2926
        """See Branch.set_revision_history."""
 
2927
        self._set_revision_history(rev_history)
 
2928
 
 
2929
    @needs_write_lock
 
2930
    def _set_revision_history(self, rev_history):
2594
2931
        # Send just the tip revision of the history; the server will generate
2595
2932
        # the full history from that.  If the revision doesn't exist in this
2596
2933
        # branch, NoSuchRevision will be raised.
2673
3010
        # XXX: These should be returned by the set_last_revision_info verb
2674
3011
        old_revno, old_revid = self.last_revision_info()
2675
3012
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
2676
 
        revision_id = ensure_null(revision_id)
 
3013
        if not revision_id or not isinstance(revision_id, basestring):
 
3014
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2677
3015
        try:
2678
3016
            response = self._call('Branch.set_last_revision_info',
2679
3017
                self._remote_path(), self._lock_token, self._repo_lock_token,
2708
3046
            except errors.UnknownSmartMethod:
2709
3047
                medium._remember_remote_is_before((1, 6))
2710
3048
        self._clear_cached_state_of_remote_branch_only()
2711
 
        self.set_revision_history(self._lefthand_history(revision_id,
 
3049
        self._set_revision_history(self._lefthand_history(revision_id,
2712
3050
            last_rev=last_rev,other_branch=other_branch))
2713
3051
 
2714
3052
    def set_push_location(self, location):
2715
3053
        self._ensure_real()
2716
3054
        return self._real_branch.set_push_location(location)
2717
3055
 
 
3056
    def heads_to_fetch(self):
 
3057
        if self._format._use_default_local_heads_to_fetch():
 
3058
            # We recognise this format, and its heads-to-fetch implementation
 
3059
            # is the default one (tip + tags).  In this case it's cheaper to
 
3060
            # just use the default implementation rather than a special RPC as
 
3061
            # the tip and tags data is cached.
 
3062
            return branch.Branch.heads_to_fetch(self)
 
3063
        medium = self._client._medium
 
3064
        if medium._is_remote_before((2, 4)):
 
3065
            return self._vfs_heads_to_fetch()
 
3066
        try:
 
3067
            return self._rpc_heads_to_fetch()
 
3068
        except errors.UnknownSmartMethod:
 
3069
            medium._remember_remote_is_before((2, 4))
 
3070
            return self._vfs_heads_to_fetch()
 
3071
 
 
3072
    def _rpc_heads_to_fetch(self):
 
3073
        response = self._call('Branch.heads_to_fetch', self._remote_path())
 
3074
        if len(response) != 2:
 
3075
            raise errors.UnexpectedSmartServerResponse(response)
 
3076
        must_fetch, if_present_fetch = response
 
3077
        return set(must_fetch), set(if_present_fetch)
 
3078
 
 
3079
    def _vfs_heads_to_fetch(self):
 
3080
        self._ensure_real()
 
3081
        return self._real_branch.heads_to_fetch()
 
3082
 
2718
3083
 
2719
3084
class RemoteConfig(object):
2720
3085
    """A Config that reads and writes from smart verbs.
2774
3139
        medium = self._branch._client._medium
2775
3140
        if medium._is_remote_before((1, 14)):
2776
3141
            return self._vfs_set_option(value, name, section)
 
3142
        if isinstance(value, dict):
 
3143
            if medium._is_remote_before((2, 2)):
 
3144
                return self._vfs_set_option(value, name, section)
 
3145
            return self._set_config_option_dict(value, name, section)
 
3146
        else:
 
3147
            return self._set_config_option(value, name, section)
 
3148
 
 
3149
    def _set_config_option(self, value, name, section):
2777
3150
        try:
2778
3151
            path = self._branch._remote_path()
2779
3152
            response = self._branch._client.call('Branch.set_config_option',
2780
3153
                path, self._branch._lock_token, self._branch._repo_lock_token,
2781
3154
                value.encode('utf8'), name, section or '')
2782
3155
        except errors.UnknownSmartMethod:
 
3156
            medium = self._branch._client._medium
2783
3157
            medium._remember_remote_is_before((1, 14))
2784
3158
            return self._vfs_set_option(value, name, section)
2785
3159
        if response != ():
2786
3160
            raise errors.UnexpectedSmartServerResponse(response)
2787
3161
 
 
3162
    def _serialize_option_dict(self, option_dict):
 
3163
        utf8_dict = {}
 
3164
        for key, value in option_dict.items():
 
3165
            if isinstance(key, unicode):
 
3166
                key = key.encode('utf8')
 
3167
            if isinstance(value, unicode):
 
3168
                value = value.encode('utf8')
 
3169
            utf8_dict[key] = value
 
3170
        return bencode.bencode(utf8_dict)
 
3171
 
 
3172
    def _set_config_option_dict(self, value, name, section):
 
3173
        try:
 
3174
            path = self._branch._remote_path()
 
3175
            serialised_dict = self._serialize_option_dict(value)
 
3176
            response = self._branch._client.call(
 
3177
                'Branch.set_config_option_dict',
 
3178
                path, self._branch._lock_token, self._branch._repo_lock_token,
 
3179
                serialised_dict, name, section or '')
 
3180
        except errors.UnknownSmartMethod:
 
3181
            medium = self._branch._client._medium
 
3182
            medium._remember_remote_is_before((2, 2))
 
3183
            return self._vfs_set_option(value, name, section)
 
3184
        if response != ():
 
3185
            raise errors.UnexpectedSmartServerResponse(response)
 
3186
 
2788
3187
    def _real_object(self):
2789
3188
        self._branch._ensure_real()
2790
3189
        return self._branch._real_branch
2873
3272
                    'Missing key %r in context %r', key_err.args[0], context)
2874
3273
                raise err
2875
3274
 
2876
 
    if err.error_verb == 'IncompatibleRepositories':
2877
 
        raise errors.IncompatibleRepositories(err.error_args[0],
2878
 
            err.error_args[1], err.error_args[2])
2879
 
    elif err.error_verb == 'NoSuchRevision':
 
3275
    if err.error_verb == 'NoSuchRevision':
2880
3276
        raise NoSuchRevision(find('branch'), err.error_args[0])
2881
3277
    elif err.error_verb == 'nosuchrevision':
2882
3278
        raise NoSuchRevision(find('repository'), err.error_args[0])
2889
3285
            detail=extra)
2890
3286
    elif err.error_verb == 'norepository':
2891
3287
        raise errors.NoRepositoryPresent(find('bzrdir'))
2892
 
    elif err.error_verb == 'LockContention':
2893
 
        raise errors.LockContention('(remote lock)')
2894
3288
    elif err.error_verb == 'UnlockableTransport':
2895
3289
        raise errors.UnlockableTransport(find('bzrdir').root_transport)
2896
 
    elif err.error_verb == 'LockFailed':
2897
 
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
2898
3290
    elif err.error_verb == 'TokenMismatch':
2899
3291
        raise errors.TokenMismatch(find('token'), '(remote token)')
2900
3292
    elif err.error_verb == 'Diverged':
2901
3293
        raise errors.DivergedBranches(find('branch'), find('other_branch'))
2902
 
    elif err.error_verb == 'TipChangeRejected':
2903
 
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
2904
 
    elif err.error_verb == 'UnstackableBranchFormat':
2905
 
        raise errors.UnstackableBranchFormat(*err.error_args)
2906
 
    elif err.error_verb == 'UnstackableRepositoryFormat':
2907
 
        raise errors.UnstackableRepositoryFormat(*err.error_args)
2908
3294
    elif err.error_verb == 'NotStacked':
2909
3295
        raise errors.NotStacked(branch=find('branch'))
2910
3296
    elif err.error_verb == 'PermissionDenied':
2920
3306
    elif err.error_verb == 'NoSuchFile':
2921
3307
        path = get_path()
2922
3308
        raise errors.NoSuchFile(path)
 
3309
    _translate_error_without_context(err)
 
3310
 
 
3311
 
 
3312
def _translate_error_without_context(err):
 
3313
    """Translate any ErrorFromSmartServer values that don't require context"""
 
3314
    if err.error_verb == 'IncompatibleRepositories':
 
3315
        raise errors.IncompatibleRepositories(err.error_args[0],
 
3316
            err.error_args[1], err.error_args[2])
 
3317
    elif err.error_verb == 'LockContention':
 
3318
        raise errors.LockContention('(remote lock)')
 
3319
    elif err.error_verb == 'LockFailed':
 
3320
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
 
3321
    elif err.error_verb == 'TipChangeRejected':
 
3322
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
 
3323
    elif err.error_verb == 'UnstackableBranchFormat':
 
3324
        raise errors.UnstackableBranchFormat(*err.error_args)
 
3325
    elif err.error_verb == 'UnstackableRepositoryFormat':
 
3326
        raise errors.UnstackableRepositoryFormat(*err.error_args)
2923
3327
    elif err.error_verb == 'FileExists':
2924
3328
        raise errors.FileExists(err.error_args[0])
2925
3329
    elif err.error_verb == 'DirectoryNotEmpty':
2944
3348
            raise UnicodeEncodeError(encoding, val, start, end, reason)
2945
3349
    elif err.error_verb == 'ReadOnlyError':
2946
3350
        raise errors.TransportNotPossible('readonly transport')
 
3351
    elif err.error_verb == 'MemoryError':
 
3352
        raise errors.BzrError("remote server out of memory\n"
 
3353
            "Retry non-remotely, or contact the server admin for details.")
2947
3354
    raise errors.UnknownErrorFromSmartServer(err)