/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: Martin Pool
  • Date: 2011-04-15 07:01:22 UTC
  • mto: This revision was merged to the branch mainline in revision 5789.
  • Revision ID: mbp@sourcefrog.net-20110415070122-7x24skeadcm7wvut
Switch away from using failUnlessExists and failIfExists

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,
 
34
    urlutils,
35
35
)
36
 
from bzrlib.branch import BranchReferenceFormat
37
 
from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat
 
36
from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult
38
37
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
39
38
from bzrlib.errors import (
40
39
    NoSuchRevision,
42
41
    )
43
42
from bzrlib.lockable_files import LockableFiles
44
43
from bzrlib.smart import client, vfs, repository as smart_repo
45
 
from bzrlib.revision import ensure_null, NULL_REVISION
 
44
from bzrlib.smart.client import _SmartClient
 
45
from bzrlib.revision import NULL_REVISION
 
46
from bzrlib.repository import RepositoryWriteLockResult
46
47
from bzrlib.trace import mutter, note, warning
47
48
 
48
49
 
86
87
    return format
87
88
 
88
89
 
89
 
# Note: RemoteBzrDirFormat is in bzrdir.py
90
 
 
91
 
class RemoteBzrDir(BzrDir, _RpcHelper):
 
90
# Note that RemoteBzrDirProber lives in bzrlib.bzrdir so bzrlib.remote
 
91
# does not have to be imported unless a remote format is involved.
 
92
 
 
93
class RemoteBzrDirFormat(_mod_bzrdir.BzrDirMetaFormat1):
 
94
    """Format representing bzrdirs accessed via a smart server"""
 
95
 
 
96
    supports_workingtrees = False
 
97
 
 
98
    def __init__(self):
 
99
        _mod_bzrdir.BzrDirMetaFormat1.__init__(self)
 
100
        # XXX: It's a bit ugly that the network name is here, because we'd
 
101
        # like to believe that format objects are stateless or at least
 
102
        # immutable,  However, we do at least avoid mutating the name after
 
103
        # it's returned.  See <https://bugs.launchpad.net/bzr/+bug/504102>
 
104
        self._network_name = None
 
105
 
 
106
    def __repr__(self):
 
107
        return "%s(_network_name=%r)" % (self.__class__.__name__,
 
108
            self._network_name)
 
109
 
 
110
    def get_format_description(self):
 
111
        if self._network_name:
 
112
            real_format = controldir.network_format_registry.get(self._network_name)
 
113
            return 'Remote: ' + real_format.get_format_description()
 
114
        return 'bzr remote bzrdir'
 
115
 
 
116
    def get_format_string(self):
 
117
        raise NotImplementedError(self.get_format_string)
 
118
 
 
119
    def network_name(self):
 
120
        if self._network_name:
 
121
            return self._network_name
 
122
        else:
 
123
            raise AssertionError("No network name set.")
 
124
 
 
125
    def initialize_on_transport(self, transport):
 
126
        try:
 
127
            # hand off the request to the smart server
 
128
            client_medium = transport.get_smart_medium()
 
129
        except errors.NoSmartMedium:
 
130
            # TODO: lookup the local format from a server hint.
 
131
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
132
            return local_dir_format.initialize_on_transport(transport)
 
133
        client = _SmartClient(client_medium)
 
134
        path = client.remote_path_from_transport(transport)
 
135
        try:
 
136
            response = client.call('BzrDirFormat.initialize', path)
 
137
        except errors.ErrorFromSmartServer, err:
 
138
            _translate_error(err, path=path)
 
139
        if response[0] != 'ok':
 
140
            raise errors.SmartProtocolError('unexpected response code %s' % (response,))
 
141
        format = RemoteBzrDirFormat()
 
142
        self._supply_sub_formats_to(format)
 
143
        return RemoteBzrDir(transport, format)
 
144
 
 
145
    def parse_NoneTrueFalse(self, arg):
 
146
        if not arg:
 
147
            return None
 
148
        if arg == 'False':
 
149
            return False
 
150
        if arg == 'True':
 
151
            return True
 
152
        raise AssertionError("invalid arg %r" % arg)
 
153
 
 
154
    def _serialize_NoneTrueFalse(self, arg):
 
155
        if arg is False:
 
156
            return 'False'
 
157
        if arg:
 
158
            return 'True'
 
159
        return ''
 
160
 
 
161
    def _serialize_NoneString(self, arg):
 
162
        return arg or ''
 
163
 
 
164
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
 
165
        create_prefix=False, force_new_repo=False, stacked_on=None,
 
166
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
 
167
        shared_repo=False):
 
168
        try:
 
169
            # hand off the request to the smart server
 
170
            client_medium = transport.get_smart_medium()
 
171
        except errors.NoSmartMedium:
 
172
            do_vfs = True
 
173
        else:
 
174
            # Decline to open it if the server doesn't support our required
 
175
            # version (3) so that the VFS-based transport will do it.
 
176
            if client_medium.should_probe():
 
177
                try:
 
178
                    server_version = client_medium.protocol_version()
 
179
                    if server_version != '2':
 
180
                        do_vfs = True
 
181
                    else:
 
182
                        do_vfs = False
 
183
                except errors.SmartProtocolError:
 
184
                    # Apparently there's no usable smart server there, even though
 
185
                    # the medium supports the smart protocol.
 
186
                    do_vfs = True
 
187
            else:
 
188
                do_vfs = False
 
189
        if not do_vfs:
 
190
            client = _SmartClient(client_medium)
 
191
            path = client.remote_path_from_transport(transport)
 
192
            if client_medium._is_remote_before((1, 16)):
 
193
                do_vfs = True
 
194
        if do_vfs:
 
195
            # TODO: lookup the local format from a server hint.
 
196
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
197
            self._supply_sub_formats_to(local_dir_format)
 
198
            return local_dir_format.initialize_on_transport_ex(transport,
 
199
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
200
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
201
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
202
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
203
                vfs_only=True)
 
204
        return self._initialize_on_transport_ex_rpc(client, path, transport,
 
205
            use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
206
            stack_on_pwd, repo_format_name, make_working_trees, shared_repo)
 
207
 
 
208
    def _initialize_on_transport_ex_rpc(self, client, path, transport,
 
209
        use_existing_dir, create_prefix, force_new_repo, stacked_on,
 
210
        stack_on_pwd, repo_format_name, make_working_trees, shared_repo):
 
211
        args = []
 
212
        args.append(self._serialize_NoneTrueFalse(use_existing_dir))
 
213
        args.append(self._serialize_NoneTrueFalse(create_prefix))
 
214
        args.append(self._serialize_NoneTrueFalse(force_new_repo))
 
215
        args.append(self._serialize_NoneString(stacked_on))
 
216
        # stack_on_pwd is often/usually our transport
 
217
        if stack_on_pwd:
 
218
            try:
 
219
                stack_on_pwd = transport.relpath(stack_on_pwd)
 
220
                if not stack_on_pwd:
 
221
                    stack_on_pwd = '.'
 
222
            except errors.PathNotChild:
 
223
                pass
 
224
        args.append(self._serialize_NoneString(stack_on_pwd))
 
225
        args.append(self._serialize_NoneString(repo_format_name))
 
226
        args.append(self._serialize_NoneTrueFalse(make_working_trees))
 
227
        args.append(self._serialize_NoneTrueFalse(shared_repo))
 
228
        request_network_name = self._network_name or \
 
229
            _mod_bzrdir.BzrDirFormat.get_default_format().network_name()
 
230
        try:
 
231
            response = client.call('BzrDirFormat.initialize_ex_1.16',
 
232
                request_network_name, path, *args)
 
233
        except errors.UnknownSmartMethod:
 
234
            client._medium._remember_remote_is_before((1,16))
 
235
            local_dir_format = _mod_bzrdir.BzrDirMetaFormat1()
 
236
            self._supply_sub_formats_to(local_dir_format)
 
237
            return local_dir_format.initialize_on_transport_ex(transport,
 
238
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
239
                force_new_repo=force_new_repo, stacked_on=stacked_on,
 
240
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
241
                make_working_trees=make_working_trees, shared_repo=shared_repo,
 
242
                vfs_only=True)
 
243
        except errors.ErrorFromSmartServer, err:
 
244
            _translate_error(err, path=path)
 
245
        repo_path = response[0]
 
246
        bzrdir_name = response[6]
 
247
        require_stacking = response[7]
 
248
        require_stacking = self.parse_NoneTrueFalse(require_stacking)
 
249
        format = RemoteBzrDirFormat()
 
250
        format._network_name = bzrdir_name
 
251
        self._supply_sub_formats_to(format)
 
252
        bzrdir = RemoteBzrDir(transport, format, _client=client)
 
253
        if repo_path:
 
254
            repo_format = response_tuple_to_repo_format(response[1:])
 
255
            if repo_path == '.':
 
256
                repo_path = ''
 
257
            if repo_path:
 
258
                repo_bzrdir_format = RemoteBzrDirFormat()
 
259
                repo_bzrdir_format._network_name = response[5]
 
260
                repo_bzr = RemoteBzrDir(transport.clone(repo_path),
 
261
                    repo_bzrdir_format)
 
262
            else:
 
263
                repo_bzr = bzrdir
 
264
            final_stack = response[8] or None
 
265
            final_stack_pwd = response[9] or None
 
266
            if final_stack_pwd:
 
267
                final_stack_pwd = urlutils.join(
 
268
                    transport.base, final_stack_pwd)
 
269
            remote_repo = RemoteRepository(repo_bzr, repo_format)
 
270
            if len(response) > 10:
 
271
                # Updated server verb that locks remotely.
 
272
                repo_lock_token = response[10] or None
 
273
                remote_repo.lock_write(repo_lock_token, _skip_rpc=True)
 
274
                if repo_lock_token:
 
275
                    remote_repo.dont_leave_lock_in_place()
 
276
            else:
 
277
                remote_repo.lock_write()
 
278
            policy = _mod_bzrdir.UseExistingRepository(remote_repo, final_stack,
 
279
                final_stack_pwd, require_stacking)
 
280
            policy.acquire_repository()
 
281
        else:
 
282
            remote_repo = None
 
283
            policy = None
 
284
        bzrdir._format.set_branch_format(self.get_branch_format())
 
285
        if require_stacking:
 
286
            # The repo has already been created, but we need to make sure that
 
287
            # we'll make a stackable branch.
 
288
            bzrdir._format.require_stacking(_skip_repo=True)
 
289
        return remote_repo, bzrdir, require_stacking, policy
 
290
 
 
291
    def _open(self, transport):
 
292
        return RemoteBzrDir(transport, self)
 
293
 
 
294
    def __eq__(self, other):
 
295
        if not isinstance(other, RemoteBzrDirFormat):
 
296
            return False
 
297
        return self.get_format_description() == other.get_format_description()
 
298
 
 
299
    def __return_repository_format(self):
 
300
        # Always return a RemoteRepositoryFormat object, but if a specific bzr
 
301
        # repository format has been asked for, tell the RemoteRepositoryFormat
 
302
        # that it should use that for init() etc.
 
303
        result = RemoteRepositoryFormat()
 
304
        custom_format = getattr(self, '_repository_format', None)
 
305
        if custom_format:
 
306
            if isinstance(custom_format, RemoteRepositoryFormat):
 
307
                return custom_format
 
308
            else:
 
309
                # We will use the custom format to create repositories over the
 
310
                # wire; expose its details like rich_root_data for code to
 
311
                # query
 
312
                result._custom_format = custom_format
 
313
        return result
 
314
 
 
315
    def get_branch_format(self):
 
316
        result = _mod_bzrdir.BzrDirMetaFormat1.get_branch_format(self)
 
317
        if not isinstance(result, RemoteBranchFormat):
 
318
            new_result = RemoteBranchFormat()
 
319
            new_result._custom_format = result
 
320
            # cache the result
 
321
            self.set_branch_format(new_result)
 
322
            result = new_result
 
323
        return result
 
324
 
 
325
    repository_format = property(__return_repository_format,
 
326
        _mod_bzrdir.BzrDirMetaFormat1._set_repository_format) #.im_func)
 
327
 
 
328
 
 
329
class RemoteBzrDir(_mod_bzrdir.BzrDir, _RpcHelper):
92
330
    """Control directory on a remote server, accessed via bzr:// or similar."""
93
331
 
94
332
    def __init__(self, transport, format, _client=None, _force_probe=False):
97
335
        :param _client: Private parameter for testing. Disables probing and the
98
336
            use of a real bzrdir.
99
337
        """
100
 
        BzrDir.__init__(self, transport, format)
 
338
        _mod_bzrdir.BzrDir.__init__(self, transport, format)
101
339
        # this object holds a delegated bzrdir that uses file-level operations
102
340
        # to talk to the other side
103
341
        self._real_bzrdir = None
163
401
                import traceback
164
402
                warning('VFS BzrDir access triggered\n%s',
165
403
                    ''.join(traceback.format_stack()))
166
 
            self._real_bzrdir = BzrDir.open_from_transport(
 
404
            self._real_bzrdir = _mod_bzrdir.BzrDir.open_from_transport(
167
405
                self.root_transport, _server_formats=False)
168
406
            self._format._network_name = \
169
407
                self._real_bzrdir._format.network_name()
175
413
        # Prevent aliasing problems in the next_open_branch_result cache.
176
414
        # See create_branch for rationale.
177
415
        self._next_open_branch_result = None
178
 
        return BzrDir.break_lock(self)
 
416
        return _mod_bzrdir.BzrDir.break_lock(self)
179
417
 
180
418
    def _vfs_cloning_metadir(self, require_stacking=False):
181
419
        self._ensure_real()
212
450
        if len(branch_info) != 2:
213
451
            raise errors.UnexpectedSmartServerResponse(response)
214
452
        branch_ref, branch_name = branch_info
215
 
        format = bzrdir.network_format_registry.get(control_name)
 
453
        format = controldir.network_format_registry.get(control_name)
216
454
        if repo_name:
217
 
            format.repository_format = repository.network_format_registry.get(
 
455
            format.repository_format = _mod_repository.network_format_registry.get(
218
456
                repo_name)
219
457
        if branch_ref == 'ref':
220
458
            # XXX: we need possible_transports here to avoid reopening the
221
459
            # connection to the referenced location
222
 
            ref_bzrdir = BzrDir.open(branch_name)
 
460
            ref_bzrdir = _mod_bzrdir.BzrDir.open(branch_name)
223
461
            branch_format = ref_bzrdir.cloning_metadir().get_branch_format()
224
462
            format.set_branch_format(branch_format)
225
463
        elif branch_ref == 'branch':
244
482
        self._ensure_real()
245
483
        self._real_bzrdir.destroy_repository()
246
484
 
247
 
    def create_branch(self, name=None):
 
485
    def create_branch(self, name=None, repository=None):
248
486
        # as per meta1 formats - just delegate to the format object which may
249
487
        # be parameterised.
250
488
        real_branch = self._format.get_branch_format().initialize(self,
251
 
            name=name)
 
489
            name=name, repository=repository)
252
490
        if not isinstance(real_branch, RemoteBranch):
253
 
            result = RemoteBranch(self, self.find_repository(), real_branch,
254
 
                                  name=name)
 
491
            if not isinstance(repository, RemoteRepository):
 
492
                raise AssertionError(
 
493
                    'need a RemoteRepository to use with RemoteBranch, got %r'
 
494
                    % (repository,))
 
495
            result = RemoteBranch(self, repository, real_branch, name=name)
255
496
        else:
256
497
            result = real_branch
257
498
        # BzrDir.clone_on_transport() uses the result of create_branch but does
269
510
        self._real_bzrdir.destroy_branch(name=name)
270
511
        self._next_open_branch_result = None
271
512
 
272
 
    def create_workingtree(self, revision_id=None, from_branch=None):
 
513
    def create_workingtree(self, revision_id=None, from_branch=None,
 
514
        accelerator_tree=None, hardlink=False):
273
515
        raise errors.NotLocalUrl(self.transport.base)
274
516
 
275
 
    def find_branch_format(self):
 
517
    def find_branch_format(self, name=None):
276
518
        """Find the branch 'format' for this bzrdir.
277
519
 
278
520
        This might be a synthetic object for e.g. RemoteBranch and SVN.
279
521
        """
280
 
        b = self.open_branch()
 
522
        b = self.open_branch(name=name)
281
523
        return b._format
282
524
 
283
 
    def get_branch_reference(self):
 
525
    def get_branch_reference(self, name=None):
284
526
        """See BzrDir.get_branch_reference()."""
 
527
        if name is not None:
 
528
            # XXX JRV20100304: Support opening colocated branches
 
529
            raise errors.NoColocatedBranchSupport(self)
285
530
        response = self._get_branch_reference()
286
531
        if response[0] == 'ref':
287
532
            return response[1]
318
563
            raise errors.UnexpectedSmartServerResponse(response)
319
564
        return response
320
565
 
321
 
    def _get_tree_branch(self):
 
566
    def _get_tree_branch(self, name=None):
322
567
        """See BzrDir._get_tree_branch()."""
323
 
        return None, self.open_branch()
 
568
        return None, self.open_branch(name=name)
324
569
 
325
570
    def open_branch(self, name=None, unsupported=False,
326
571
                    ignore_fallbacks=False):
441
686
        """Upgrading of remote bzrdirs is not supported yet."""
442
687
        return False
443
688
 
444
 
    def needs_format_conversion(self, format=None):
 
689
    def needs_format_conversion(self, format):
445
690
        """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
691
        return False
450
692
 
451
693
    def clone(self, url, revision_id=None, force_new_repo=False,
458
700
        return RemoteBzrDirConfig(self)
459
701
 
460
702
 
461
 
class RemoteRepositoryFormat(repository.RepositoryFormat):
 
703
class RemoteRepositoryFormat(_mod_repository.RepositoryFormat):
462
704
    """Format for repositories accessed over a _SmartClient.
463
705
 
464
706
    Instances of this repository are represented by RemoteRepository
479
721
    """
480
722
 
481
723
    _matchingbzrdir = RemoteBzrDirFormat()
 
724
    supports_full_versioned_files = True
 
725
    supports_leaving_lock = True
482
726
 
483
727
    def __init__(self):
484
 
        repository.RepositoryFormat.__init__(self)
 
728
        _mod_repository.RepositoryFormat.__init__(self)
485
729
        self._custom_format = None
486
730
        self._network_name = None
487
731
        self._creating_bzrdir = None
 
732
        self._revision_graph_can_have_wrong_parents = None
488
733
        self._supports_chks = None
489
734
        self._supports_external_lookups = None
490
735
        self._supports_tree_reference = None
 
736
        self._supports_funky_characters = None
491
737
        self._rich_root_data = None
492
738
 
493
739
    def __repr__(self):
522
768
        return self._supports_external_lookups
523
769
 
524
770
    @property
 
771
    def supports_funky_characters(self):
 
772
        if self._supports_funky_characters is None:
 
773
            self._ensure_real()
 
774
            self._supports_funky_characters = \
 
775
                self._custom_format.supports_funky_characters
 
776
        return self._supports_funky_characters
 
777
 
 
778
    @property
525
779
    def supports_tree_reference(self):
526
780
        if self._supports_tree_reference is None:
527
781
            self._ensure_real()
529
783
                self._custom_format.supports_tree_reference
530
784
        return self._supports_tree_reference
531
785
 
 
786
    @property
 
787
    def revision_graph_can_have_wrong_parents(self):
 
788
        if self._revision_graph_can_have_wrong_parents is None:
 
789
            self._ensure_real()
 
790
            self._revision_graph_can_have_wrong_parents = \
 
791
                self._custom_format.revision_graph_can_have_wrong_parents
 
792
        return self._revision_graph_can_have_wrong_parents
 
793
 
532
794
    def _vfs_initialize(self, a_bzrdir, shared):
533
795
        """Helper for common code in initialize."""
534
796
        if self._custom_format:
569
831
            network_name = self._network_name
570
832
        else:
571
833
            # Select the current bzrlib default and ask for that.
572
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
834
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
573
835
            reference_format = reference_bzrdir_format.repository_format
574
836
            network_name = reference_format.network_name()
575
837
        # 2) try direct creation via RPC
601
863
 
602
864
    def _ensure_real(self):
603
865
        if self._custom_format is None:
604
 
            self._custom_format = repository.network_format_registry.get(
 
866
            self._custom_format = _mod_repository.network_format_registry.get(
605
867
                self._network_name)
606
868
 
607
869
    @property
644
906
 
645
907
 
646
908
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
647
 
    bzrdir.ControlComponent):
 
909
    controldir.ControlComponent):
648
910
    """Repository accessed over rpc.
649
911
 
650
912
    For the moment most operations are performed using local transport-backed
703
965
        # transport, but I'm not sure it's worth making this method
704
966
        # optional -- mbp 2010-04-21
705
967
        return self.bzrdir.get_repository_transport(None)
706
 
        
 
968
 
707
969
    def __str__(self):
708
970
        return "%s(%s)" % (self.__class__.__name__, self.base)
709
971
 
843
1105
        """Private method for using with old (< 1.2) servers to fallback."""
844
1106
        if revision_id is None:
845
1107
            revision_id = ''
846
 
        elif revision.is_null(revision_id):
 
1108
        elif _mod_revision.is_null(revision_id):
847
1109
            return {}
848
1110
 
849
1111
        path = self.bzrdir._path_for_remote_call(self._client)
895
1157
    def _has_same_fallbacks(self, other_repo):
896
1158
        """Returns true if the repositories have the same fallbacks."""
897
1159
        # XXX: copied from Repository; it should be unified into a base class
898
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
 
1160
        # <https://bugs.launchpad.net/bzr/+bug/401622>
899
1161
        my_fb = self._fallback_repositories
900
1162
        other_fb = other_repo._fallback_repositories
901
1163
        if len(my_fb) != len(other_fb):
930
1192
        """See Repository.gather_stats()."""
931
1193
        path = self.bzrdir._path_for_remote_call(self._client)
932
1194
        # revid can be None to indicate no revisions, not just NULL_REVISION
933
 
        if revid is None or revision.is_null(revid):
 
1195
        if revid is None or _mod_revision.is_null(revid):
934
1196
            fmt_revid = ''
935
1197
        else:
936
1198
            fmt_revid = revid
997
1259
        pass
998
1260
 
999
1261
    def lock_read(self):
 
1262
        """Lock the repository for read operations.
 
1263
 
 
1264
        :return: A bzrlib.lock.LogicalLockResult.
 
1265
        """
1000
1266
        # wrong eventually - want a local lock cache context
1001
1267
        if not self._lock_mode:
1002
1268
            self._note_lock('r')
1009
1275
                repo.lock_read()
1010
1276
        else:
1011
1277
            self._lock_count += 1
 
1278
        return lock.LogicalLockResult(self.unlock)
1012
1279
 
1013
1280
    def _remote_lock_write(self, token):
1014
1281
        path = self.bzrdir._path_for_remote_call(self._client)
1054
1321
            raise errors.ReadOnlyError(self)
1055
1322
        else:
1056
1323
            self._lock_count += 1
1057
 
        return self._lock_token or None
 
1324
        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)
1058
1325
 
1059
1326
    def leave_lock_in_place(self):
1060
1327
        if not self._lock_token:
1306
1573
        return self._real_repository.make_working_trees()
1307
1574
 
1308
1575
    def refresh_data(self):
1309
 
        """Re-read any data needed to to synchronise with disk.
 
1576
        """Re-read any data needed to synchronise with disk.
1310
1577
 
1311
1578
        This method is intended to be called after another repository instance
1312
1579
        (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.
 
1580
        repository. On all repositories this will work outside of write groups.
 
1581
        Some repository formats (pack and newer for bzrlib native formats)
 
1582
        support refresh_data inside write groups. If called inside a write
 
1583
        group on a repository that does not support refreshing in a write group
 
1584
        IsInWriteGroupError will be raised.
1315
1585
        """
1316
 
        if self.is_in_write_group():
1317
 
            raise errors.InternalBzrError(
1318
 
                "May not refresh_data while in a write group.")
1319
1586
        if self._real_repository is not None:
1320
1587
            self._real_repository.refresh_data()
1321
1588
 
1333
1600
        return result
1334
1601
 
1335
1602
    @needs_read_lock
1336
 
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
 
1603
    def search_missing_revision_ids(self, other,
 
1604
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
 
1605
            find_ghosts=True, revision_ids=None, if_present_ids=None):
1337
1606
        """Return the revision ids that other has that this does not.
1338
1607
 
1339
1608
        These are returned in topological order.
1340
1609
 
1341
1610
        revision_id: only return revision ids included by revision_id.
1342
1611
        """
1343
 
        return repository.InterRepository.get(
1344
 
            other, self).search_missing_revision_ids(revision_id, find_ghosts)
 
1612
        if symbol_versioning.deprecated_passed(revision_id):
 
1613
            symbol_versioning.warn(
 
1614
                'search_missing_revision_ids(revision_id=...) was '
 
1615
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
 
1616
                DeprecationWarning, stacklevel=2)
 
1617
            if revision_ids is not None:
 
1618
                raise AssertionError(
 
1619
                    'revision_ids is mutually exclusive with revision_id')
 
1620
            if revision_id is not None:
 
1621
                revision_ids = [revision_id]
 
1622
        inter_repo = _mod_repository.InterRepository.get(other, self)
 
1623
        return inter_repo.search_missing_revision_ids(
 
1624
            find_ghosts=find_ghosts, revision_ids=revision_ids,
 
1625
            if_present_ids=if_present_ids)
1345
1626
 
1346
 
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
 
1627
    def fetch(self, source, revision_id=None, find_ghosts=False,
1347
1628
            fetch_spec=None):
1348
1629
        # No base implementation to use as RemoteRepository is not a subclass
1349
1630
        # of Repository; so this is a copy of Repository.fetch().
1360
1641
            # check that last_revision is in 'from' and then return a
1361
1642
            # no-operation.
1362
1643
            if (revision_id is not None and
1363
 
                not revision.is_null(revision_id)):
 
1644
                not _mod_revision.is_null(revision_id)):
1364
1645
                self.get_revision(revision_id)
1365
1646
            return 0, []
1366
1647
        # if there is no specific appropriate InterRepository, this will get
1367
1648
        # the InterRepository base class, which raises an
1368
1649
        # IncompatibleRepositories when asked to fetch.
1369
 
        inter = repository.InterRepository.get(source, self)
1370
 
        return inter.fetch(revision_id=revision_id, pb=pb,
 
1650
        inter = _mod_repository.InterRepository.get(source, self)
 
1651
        return inter.fetch(revision_id=revision_id,
1371
1652
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
1372
1653
 
1373
1654
    def create_bundle(self, target, base, fileobj, format=None):
1597
1878
            tmpdir = osutils.mkdtemp()
1598
1879
            try:
1599
1880
                _extract_tar(tar, tmpdir)
1600
 
                tmp_bzrdir = BzrDir.open(tmpdir)
 
1881
                tmp_bzrdir = _mod_bzrdir.BzrDir.open(tmpdir)
1601
1882
                tmp_repo = tmp_bzrdir.open_repository()
1602
1883
                tmp_repo.copy_content_into(destination, revision_id)
1603
1884
            finally:
1714
1995
        return self._real_repository.item_keys_introduced_by(revision_ids,
1715
1996
            _files_pb=_files_pb)
1716
1997
 
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
1998
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
1723
1999
        self._ensure_real()
1724
2000
        return self._real_repository._find_inconsistent_revision_parents(
1748
2024
        return '\n'.join((start_keys, stop_keys, count))
1749
2025
 
1750
2026
    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)]
 
2027
        parts = search_result.get_network_struct()
1757
2028
        return '\n'.join(parts)
1758
2029
 
1759
2030
    def autopack(self):
1769
2040
            raise errors.UnexpectedSmartServerResponse(response)
1770
2041
 
1771
2042
 
1772
 
class RemoteStreamSink(repository.StreamSink):
 
2043
class RemoteStreamSink(_mod_repository.StreamSink):
1773
2044
 
1774
2045
    def _insert_real(self, stream, src_format, resume_tokens):
1775
2046
        self.target_repo._ensure_real()
1876
2147
        self._last_substream and self._last_stream so that the stream can be
1877
2148
        resumed by _resume_stream_with_vfs.
1878
2149
        """
1879
 
                    
 
2150
 
1880
2151
        stream_iter = iter(stream)
1881
2152
        for substream_kind, substream in stream_iter:
1882
2153
            if substream_kind == 'inventory-deltas':
1885
2156
                return
1886
2157
            else:
1887
2158
                yield substream_kind, substream
1888
 
            
1889
 
 
1890
 
class RemoteStreamSource(repository.StreamSource):
 
2159
 
 
2160
 
 
2161
class RemoteStreamSource(_mod_repository.StreamSource):
1891
2162
    """Stream data from a remote server."""
1892
2163
 
1893
2164
    def get_stream(self, search):
1953
2224
        candidate_verbs = [
1954
2225
            ('Repository.get_stream_1.19', (1, 19)),
1955
2226
            ('Repository.get_stream', (1, 13))]
 
2227
 
1956
2228
        found_verb = False
1957
2229
        for verb, version in candidate_verbs:
1958
2230
            if medium._is_remote_before(version):
1962
2234
                    verb, args, search_bytes)
1963
2235
            except errors.UnknownSmartMethod:
1964
2236
                medium._remember_remote_is_before(version)
 
2237
            except errors.UnknownErrorFromSmartServer, e:
 
2238
                if isinstance(search, graph.EverythingResult):
 
2239
                    error_verb = e.error_from_smart_server.error_verb
 
2240
                    if error_verb == 'BadSearch':
 
2241
                        # Pre-2.4 servers don't support this sort of search.
 
2242
                        # XXX: perhaps falling back to VFS on BadSearch is a
 
2243
                        # good idea in general?  It might provide a little bit
 
2244
                        # of protection against client-side bugs.
 
2245
                        medium._remember_remote_is_before((2, 4))
 
2246
                        break
 
2247
                raise
1965
2248
            else:
1966
2249
                response_tuple, response_handler = response
1967
2250
                found_verb = True
1971
2254
        if response_tuple[0] != 'ok':
1972
2255
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1973
2256
        byte_stream = response_handler.read_streamed_body()
1974
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
 
2257
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
 
2258
            self._record_counter)
1975
2259
        if src_format.network_name() != repo._format.network_name():
1976
2260
            raise AssertionError(
1977
2261
                "Mismatched RemoteRepository and stream src %r, %r" % (
2081
2365
                                  name=name)
2082
2366
        return result
2083
2367
 
2084
 
    def initialize(self, a_bzrdir, name=None):
 
2368
    def initialize(self, a_bzrdir, name=None, repository=None):
2085
2369
        # 1) get the network name to use.
2086
2370
        if self._custom_format:
2087
2371
            network_name = self._custom_format.network_name()
2088
2372
        else:
2089
2373
            # Select the current bzrlib default and ask for that.
2090
 
            reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
2374
            reference_bzrdir_format = _mod_bzrdir.format_registry.get('default')()
2091
2375
            reference_format = reference_bzrdir_format.get_branch_format()
2092
2376
            self._custom_format = reference_format
2093
2377
            network_name = reference_format.network_name()
2115
2399
        # Turn the response into a RemoteRepository object.
2116
2400
        format = RemoteBranchFormat(network_name=response[1])
2117
2401
        repo_format = response_tuple_to_repo_format(response[3:])
2118
 
        if response[2] == '':
2119
 
            repo_bzrdir = a_bzrdir
 
2402
        repo_path = response[2]
 
2403
        if repository is not None:
 
2404
            remote_repo_url = urlutils.join(a_bzrdir.user_url, repo_path)
 
2405
            url_diff = urlutils.relative_url(repository.user_url,
 
2406
                    remote_repo_url)
 
2407
            if url_diff != '.':
 
2408
                raise AssertionError(
 
2409
                    'repository.user_url %r does not match URL from server '
 
2410
                    'response (%r + %r)'
 
2411
                    % (repository.user_url, a_bzrdir.user_url, repo_path))
 
2412
            remote_repo = repository
2120
2413
        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)
 
2414
            if repo_path == '':
 
2415
                repo_bzrdir = a_bzrdir
 
2416
            else:
 
2417
                repo_bzrdir = RemoteBzrDir(
 
2418
                    a_bzrdir.root_transport.clone(repo_path), a_bzrdir._format,
 
2419
                    a_bzrdir._client)
 
2420
            remote_repo = RemoteRepository(repo_bzrdir, repo_format)
2125
2421
        remote_branch = RemoteBranch(a_bzrdir, remote_repo,
2126
2422
            format=format, setup_stacking=False, name=name)
2127
2423
        # XXX: We know this is a new branch, so it must have revno 0, revid
2148
2444
        self._ensure_real()
2149
2445
        return self._custom_format.supports_set_append_revisions_only()
2150
2446
 
 
2447
    def _use_default_local_heads_to_fetch(self):
 
2448
        # If the branch format is a metadir format *and* its heads_to_fetch
 
2449
        # implementation is not overridden vs the base class, we can use the
 
2450
        # base class logic rather than use the heads_to_fetch RPC.  This is
 
2451
        # usually cheaper in terms of net round trips, as the last-revision and
 
2452
        # tags info fetched is cached and would be fetched anyway.
 
2453
        self._ensure_real()
 
2454
        if isinstance(self._custom_format, branch.BranchFormatMetadir):
 
2455
            branch_class = self._custom_format._branch_class()
 
2456
            heads_to_fetch_impl = branch_class.heads_to_fetch.im_func
 
2457
            if heads_to_fetch_impl is branch.Branch.heads_to_fetch.im_func:
 
2458
                return True
 
2459
        return False
2151
2460
 
2152
2461
class RemoteBranch(branch.Branch, _RpcHelper, lock._RelockDebugMixin):
2153
2462
    """Branch stored on a server accessed by HPSS RPC.
2352
2661
            self._is_stacked = False
2353
2662
        else:
2354
2663
            self._is_stacked = True
2355
 
        
 
2664
 
2356
2665
    def _vfs_get_tags_bytes(self):
2357
2666
        self._ensure_real()
2358
2667
        return self._real_branch._get_tags_bytes()
2359
2668
 
 
2669
    @needs_read_lock
2360
2670
    def _get_tags_bytes(self):
 
2671
        if self._tags_bytes is None:
 
2672
            self._tags_bytes = self._get_tags_bytes_via_hpss()
 
2673
        return self._tags_bytes
 
2674
 
 
2675
    def _get_tags_bytes_via_hpss(self):
2361
2676
        medium = self._client._medium
2362
2677
        if medium._is_remote_before((1, 13)):
2363
2678
            return self._vfs_get_tags_bytes()
2373
2688
        return self._real_branch._set_tags_bytes(bytes)
2374
2689
 
2375
2690
    def _set_tags_bytes(self, bytes):
 
2691
        if self.is_locked():
 
2692
            self._tags_bytes = bytes
2376
2693
        medium = self._client._medium
2377
2694
        if medium._is_remote_before((1, 18)):
2378
2695
            self._vfs_set_tags_bytes(bytes)
2387
2704
            self._vfs_set_tags_bytes(bytes)
2388
2705
 
2389
2706
    def lock_read(self):
 
2707
        """Lock the branch for read operations.
 
2708
 
 
2709
        :return: A bzrlib.lock.LogicalLockResult.
 
2710
        """
2390
2711
        self.repository.lock_read()
2391
2712
        if not self._lock_mode:
2392
2713
            self._note_lock('r')
2396
2717
                self._real_branch.lock_read()
2397
2718
        else:
2398
2719
            self._lock_count += 1
 
2720
        return lock.LogicalLockResult(self.unlock)
2399
2721
 
2400
2722
    def _remote_lock_write(self, token):
2401
2723
        if token is None:
2402
2724
            branch_token = repo_token = ''
2403
2725
        else:
2404
2726
            branch_token = token
2405
 
            repo_token = self.repository.lock_write()
 
2727
            repo_token = self.repository.lock_write().repository_token
2406
2728
            self.repository.unlock()
2407
2729
        err_context = {'token': token}
2408
 
        response = self._call(
2409
 
            'Branch.lock_write', self._remote_path(), branch_token,
2410
 
            repo_token or '', **err_context)
 
2730
        try:
 
2731
            response = self._call(
 
2732
                'Branch.lock_write', self._remote_path(), branch_token,
 
2733
                repo_token or '', **err_context)
 
2734
        except errors.LockContention, e:
 
2735
            # The LockContention from the server doesn't have any
 
2736
            # information about the lock_url. We re-raise LockContention
 
2737
            # with valid lock_url.
 
2738
            raise errors.LockContention('(remote lock)',
 
2739
                self.repository.base.split('.bzr/')[0])
2411
2740
        if response[0] != 'ok':
2412
2741
            raise errors.UnexpectedSmartServerResponse(response)
2413
2742
        ok, branch_token, repo_token = response
2434
2763
            self._lock_mode = 'w'
2435
2764
            self._lock_count = 1
2436
2765
        elif self._lock_mode == 'r':
2437
 
            raise errors.ReadOnlyTransaction
 
2766
            raise errors.ReadOnlyError(self)
2438
2767
        else:
2439
2768
            if token is not None:
2440
2769
                # A token was given to lock_write, and we're relocking, so
2445
2774
            self._lock_count += 1
2446
2775
            # Re-lock the repository too.
2447
2776
            self.repository.lock_write(self._repo_lock_token)
2448
 
        return self._lock_token or None
 
2777
        return BranchWriteLockResult(self.unlock, self._lock_token or None)
2449
2778
 
2450
2779
    def _unlock(self, branch_token, repo_token):
2451
2780
        err_context = {'token': str((branch_token, repo_token))}
2673
3002
        # XXX: These should be returned by the set_last_revision_info verb
2674
3003
        old_revno, old_revid = self.last_revision_info()
2675
3004
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
2676
 
        revision_id = ensure_null(revision_id)
 
3005
        revision_id = _mod_revision.ensure_null(revision_id)
2677
3006
        try:
2678
3007
            response = self._call('Branch.set_last_revision_info',
2679
3008
                self._remote_path(), self._lock_token, self._repo_lock_token,
2715
3044
        self._ensure_real()
2716
3045
        return self._real_branch.set_push_location(location)
2717
3046
 
 
3047
    def heads_to_fetch(self):
 
3048
        if self._format._use_default_local_heads_to_fetch():
 
3049
            # We recognise this format, and its heads-to-fetch implementation
 
3050
            # is the default one (tip + tags).  In this case it's cheaper to
 
3051
            # just use the default implementation rather than a special RPC as
 
3052
            # the tip and tags data is cached.
 
3053
            return branch.Branch.heads_to_fetch(self)
 
3054
        medium = self._client._medium
 
3055
        if medium._is_remote_before((2, 4)):
 
3056
            return self._vfs_heads_to_fetch()
 
3057
        try:
 
3058
            return self._rpc_heads_to_fetch()
 
3059
        except errors.UnknownSmartMethod:
 
3060
            medium._remember_remote_is_before((2, 4))
 
3061
            return self._vfs_heads_to_fetch()
 
3062
 
 
3063
    def _rpc_heads_to_fetch(self):
 
3064
        response = self._call('Branch.heads_to_fetch', self._remote_path())
 
3065
        if len(response) != 2:
 
3066
            raise errors.UnexpectedSmartServerResponse(response)
 
3067
        must_fetch, if_present_fetch = response
 
3068
        return set(must_fetch), set(if_present_fetch)
 
3069
 
 
3070
    def _vfs_heads_to_fetch(self):
 
3071
        self._ensure_real()
 
3072
        return self._real_branch.heads_to_fetch()
 
3073
 
2718
3074
 
2719
3075
class RemoteConfig(object):
2720
3076
    """A Config that reads and writes from smart verbs.
2774
3130
        medium = self._branch._client._medium
2775
3131
        if medium._is_remote_before((1, 14)):
2776
3132
            return self._vfs_set_option(value, name, section)
 
3133
        if isinstance(value, dict):
 
3134
            if medium._is_remote_before((2, 2)):
 
3135
                return self._vfs_set_option(value, name, section)
 
3136
            return self._set_config_option_dict(value, name, section)
 
3137
        else:
 
3138
            return self._set_config_option(value, name, section)
 
3139
 
 
3140
    def _set_config_option(self, value, name, section):
2777
3141
        try:
2778
3142
            path = self._branch._remote_path()
2779
3143
            response = self._branch._client.call('Branch.set_config_option',
2780
3144
                path, self._branch._lock_token, self._branch._repo_lock_token,
2781
3145
                value.encode('utf8'), name, section or '')
2782
3146
        except errors.UnknownSmartMethod:
 
3147
            medium = self._branch._client._medium
2783
3148
            medium._remember_remote_is_before((1, 14))
2784
3149
            return self._vfs_set_option(value, name, section)
2785
3150
        if response != ():
2786
3151
            raise errors.UnexpectedSmartServerResponse(response)
2787
3152
 
 
3153
    def _serialize_option_dict(self, option_dict):
 
3154
        utf8_dict = {}
 
3155
        for key, value in option_dict.items():
 
3156
            if isinstance(key, unicode):
 
3157
                key = key.encode('utf8')
 
3158
            if isinstance(value, unicode):
 
3159
                value = value.encode('utf8')
 
3160
            utf8_dict[key] = value
 
3161
        return bencode.bencode(utf8_dict)
 
3162
 
 
3163
    def _set_config_option_dict(self, value, name, section):
 
3164
        try:
 
3165
            path = self._branch._remote_path()
 
3166
            serialised_dict = self._serialize_option_dict(value)
 
3167
            response = self._branch._client.call(
 
3168
                'Branch.set_config_option_dict',
 
3169
                path, self._branch._lock_token, self._branch._repo_lock_token,
 
3170
                serialised_dict, name, section or '')
 
3171
        except errors.UnknownSmartMethod:
 
3172
            medium = self._branch._client._medium
 
3173
            medium._remember_remote_is_before((2, 2))
 
3174
            return self._vfs_set_option(value, name, section)
 
3175
        if response != ():
 
3176
            raise errors.UnexpectedSmartServerResponse(response)
 
3177
 
2788
3178
    def _real_object(self):
2789
3179
        self._branch._ensure_real()
2790
3180
        return self._branch._real_branch
2873
3263
                    'Missing key %r in context %r', key_err.args[0], context)
2874
3264
                raise err
2875
3265
 
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':
 
3266
    if err.error_verb == 'NoSuchRevision':
2880
3267
        raise NoSuchRevision(find('branch'), err.error_args[0])
2881
3268
    elif err.error_verb == 'nosuchrevision':
2882
3269
        raise NoSuchRevision(find('repository'), err.error_args[0])
2889
3276
            detail=extra)
2890
3277
    elif err.error_verb == 'norepository':
2891
3278
        raise errors.NoRepositoryPresent(find('bzrdir'))
2892
 
    elif err.error_verb == 'LockContention':
2893
 
        raise errors.LockContention('(remote lock)')
2894
3279
    elif err.error_verb == 'UnlockableTransport':
2895
3280
        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
3281
    elif err.error_verb == 'TokenMismatch':
2899
3282
        raise errors.TokenMismatch(find('token'), '(remote token)')
2900
3283
    elif err.error_verb == 'Diverged':
2901
3284
        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
3285
    elif err.error_verb == 'NotStacked':
2909
3286
        raise errors.NotStacked(branch=find('branch'))
2910
3287
    elif err.error_verb == 'PermissionDenied':
2920
3297
    elif err.error_verb == 'NoSuchFile':
2921
3298
        path = get_path()
2922
3299
        raise errors.NoSuchFile(path)
 
3300
    _translate_error_without_context(err)
 
3301
 
 
3302
 
 
3303
def _translate_error_without_context(err):
 
3304
    """Translate any ErrorFromSmartServer values that don't require context"""
 
3305
    if err.error_verb == 'IncompatibleRepositories':
 
3306
        raise errors.IncompatibleRepositories(err.error_args[0],
 
3307
            err.error_args[1], err.error_args[2])
 
3308
    elif err.error_verb == 'LockContention':
 
3309
        raise errors.LockContention('(remote lock)')
 
3310
    elif err.error_verb == 'LockFailed':
 
3311
        raise errors.LockFailed(err.error_args[0], err.error_args[1])
 
3312
    elif err.error_verb == 'TipChangeRejected':
 
3313
        raise errors.TipChangeRejected(err.error_args[0].decode('utf8'))
 
3314
    elif err.error_verb == 'UnstackableBranchFormat':
 
3315
        raise errors.UnstackableBranchFormat(*err.error_args)
 
3316
    elif err.error_verb == 'UnstackableRepositoryFormat':
 
3317
        raise errors.UnstackableRepositoryFormat(*err.error_args)
2923
3318
    elif err.error_verb == 'FileExists':
2924
3319
        raise errors.FileExists(err.error_args[0])
2925
3320
    elif err.error_verb == 'DirectoryNotEmpty':
2944
3339
            raise UnicodeEncodeError(encoding, val, start, end, reason)
2945
3340
    elif err.error_verb == 'ReadOnlyError':
2946
3341
        raise errors.TransportNotPossible('readonly transport')
 
3342
    elif err.error_verb == 'MemoryError':
 
3343
        raise errors.BzrError("remote server out of memory\n"
 
3344
            "Retry non-remotely, or contact the server admin for details.")
2947
3345
    raise errors.UnknownErrorFromSmartServer(err)