/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: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

Show diffs side-by-side

added added

removed removed

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